luca 3.0.0 → 3.0.2

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

@@ -1,11 +1,13 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { type AvailableFeatures } from '@soederpop/luca/feature'
+import { type AvailableFeatures } from 'luca/feature'
 import { Feature } from '../feature.js'
 import type { Assistant } from './assistant.js'
+import type { ConversationHistory, ConversationMeta, ConversationRecord } from './conversation-history.js'
 import type { InterceptorFn, InterceptorPoint, InterceptorPoints } from '../lib/interceptor-chain.js'
+import hashObject from '../../hash-object.js'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
 	interface AvailableFeatures {
 		assistantsManager: typeof AssistantsManager
 	}
@@ -200,15 +202,15 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 					let meta: Record<string, any> | undefined
 
 					if (hasAbout) {
-						about = fs.readFileSync(`${folder}/ABOUT.md`, 'utf8')
+						about = fs.readFileSync(`${folder}/ABOUT.md`, 'utf8') as string
 					}
 
 					try {
-						const coreContent = fs.readFileSync(`${folder}/CORE.md`, 'utf8')
+						const coreContent = fs.readFileSync(`${folder}/CORE.md`, 'utf8') as string
 						const fmMatch = coreContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
 						if (fmMatch) {
 							const yaml = this.container.feature('yaml')
-							meta = yaml.parse(fmMatch[1])
+							meta = yaml.parse(fmMatch[1]!)
 						}
 					} catch {
 						// CORE.md exists but couldn't be parsed — skip meta
@@ -275,7 +277,22 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 	 * @returns {AssistantEntry[]} All discovered entries
 	 */
 	list(): AssistantEntry[] {
-		return Object.values(this.entries)
+		const discovered = Object.values(this.entries)
+		const discoveredNames = new Set(discovered.map((e) => e.name))
+
+		// Include registered factories that weren't discovered on disk
+		const registeredOnly = Object.keys(this.factories)
+			.filter((name) => !discoveredNames.has(name))
+			.map((name): AssistantEntry => ({
+				name,
+				folder: '',
+				hasCorePrompt: false,
+				hasTools: false,
+				hasHooks: false,
+				hasVoice: false,
+			}))
+
+		return [...discovered, ...registeredOnly]
 	}
 
 	/**
@@ -378,6 +395,105 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 		}
 	}
 
+	/**
+	 * Reload tools, hooks, and system prompt from disk for active assistants.
+	 * When called with a name, reloads only that assistant. When called without
+	 * arguments, reloads all active instances.
+	 *
+	 * @param {string} [name] - Optional assistant name to reload. Omit to reload all.
+	 * @returns {{ reloaded: string[] }} Names of assistants that were reloaded
+	 * @throws {Error} If a specific name is given but no active instance exists for it
+	 *
+	 * @example
+	 * ```typescript
+	 * manager.reload('researcher')       // reload one
+	 * manager.reload()                    // reload all active
+	 * ```
+	 */
+	reload(name?: string): { reloaded: string[] } {
+		const reloaded: string[] = []
+
+		if (name) {
+			const instance = this.instances[name]
+			if (!instance) {
+				throw new Error(
+					`No active assistant "${name}" to reload. Active: ${Object.keys(this.instances).join(', ') || '(none)'}`
+				)
+			}
+			instance.reload()
+			reloaded.push(name)
+		} else {
+			for (const [key, instance] of Object.entries(this.instances)) {
+				instance.reload()
+				reloaded.push(key)
+			}
+		}
+
+		return { reloaded }
+	}
+
+	/**
+	 * Build the thread prefix for a given assistant name, matching the
+	 * convention used by the Assistant class: `name:cwdHash:`.
+	 * This allows history lookups without an active instance.
+	 *
+	 * @param {string} assistantId - The assistant name
+	 * @returns {string} The thread prefix
+	 */
+	threadPrefixFor(assistantId: string): string {
+		const cwdHash = hashObject(this.container.cwd).slice(0, 8)
+		return `${assistantId}:${cwdHash}:`
+	}
+
+	/**
+	 * Load conversation history for an assistant. Works whether or not the
+	 * assistant is currently instantiated — uses the thread prefix convention
+	 * to query the conversationHistory feature directly.
+	 *
+	 * @param {string} assistantId - The assistant name (e.g. 'researcher')
+	 * @param {object} [options] - Query options
+	 * @param {number} [options.limit] - Maximum number of records to return
+	 * @param {boolean} [options.includeMessages] - Load full records with messages (default: false, returns metadata only)
+	 * @param {string} [options.thread] - Load a specific thread ID instead of all threads for this assistant
+	 * @returns {Promise<ConversationMeta[] | ConversationRecord[]>} Metadata or full records, newest first
+	 *
+	 * @example
+	 * ```typescript
+	 * // List recent sessions (metadata only)
+	 * const sessions = await manager.loadAssistantHistory('researcher', { limit: 5 })
+	 *
+	 * // Load full records with messages
+	 * const full = await manager.loadAssistantHistory('researcher', { includeMessages: true, limit: 3 })
+	 *
+	 * // Load a specific thread
+	 * const thread = await manager.loadAssistantHistory('researcher', { thread: 'researcher:abc12345:2026-04-12' })
+	 * ```
+	 */
+	async loadAssistantHistory(
+		assistantId: string,
+		options?: { limit?: number; includeMessages?: boolean; thread?: string },
+	): Promise<ConversationMeta[] | ConversationRecord[]> {
+		const history = this.container.feature('conversationHistory') as ConversationHistory
+
+		if (options?.thread) {
+			const record = await history.findByThread(options.thread)
+			return record ? [record] : []
+		}
+
+		const prefix = this.threadPrefixFor(assistantId)
+		const metas = await history.findByThreadPrefix(prefix)
+		const limited = options?.limit ? metas.slice(0, options.limit) : metas
+
+		if (!options?.includeMessages) return limited
+
+		const records: ConversationRecord[] = []
+		for (const meta of limited) {
+			const record = await history.load(meta.id)
+			if (record) records.push(record)
+		}
+		return records
+	}
+
 	/**
 	 * Returns a previously created assistant instance by name.
 	 *

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

@@ -4,7 +4,7 @@ import { Feature } from '../feature.js'
 import type { Assistant } from './assistant.js'
 import type { ToolCallCtx } from '../lib/interceptor-chain.js'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
 	interface AvailableFeatures {
 		autoAssistant: typeof AutonomousAssistant
 	}

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

@@ -3,7 +3,7 @@ import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '.
 import { Feature } from '../feature.js'
 import type { Helper } from '../../helper.js'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
   interface AvailableFeatures {
     browserUse: typeof BrowserUse
   }
@@ -220,6 +220,12 @@ export class BrowserUse extends Feature<BrowserUseState, BrowserUseOptions> {
       description: 'List all active browser sessions.',
       schema: z.object({}).describe('List all currently active browser sessions with their names and status.'),
     },
+    browserSetHeaded: {
+      description: 'Toggle browser visibility. Use headed mode to show the browser window, or headless mode to hide it.',
+      schema: z.object({
+        headed: z.boolean().describe('true to show the browser window (headed), false to hide it (headless)'),
+      }).describe('Toggle the browser between headed (visible window) and headless mode. When the user asks to see the browser or hide it, use this tool.'),
+    },
   }
 
   static { Feature.register(this, 'browserUse') }
@@ -490,6 +496,15 @@ export class BrowserUse extends Feature<BrowserUseState, BrowserUseOptions> {
     return this.exec('sessions')
   }
 
+  /**
+   * Toggle headed/headless mode
+   * @param headed - true for visible browser window, false for headless
+   */
+  setHeaded(headed: boolean): { success: boolean; headed: boolean } {
+    this.state.set('headed', headed)
+    return { success: true, headed }
+  }
+
   /**
    * Hover over an element
    * @param index - Element index
@@ -648,6 +663,10 @@ export class BrowserUse extends Feature<BrowserUseState, BrowserUseOptions> {
   async browserGetAttributes(options: { index: string }) {
     return this.getAttributes(options.index)
   }
+
+  async browserSetHeaded(options: { headed: boolean }) {
+    return this.setHeaded(options.headed)
+  }
 }
 
 export default BrowserUse

package/src/agi/features/claude-code.ts

@@ -1,10 +1,10 @@
 // @ts-nocheck
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { type AvailableFeatures } from '@soederpop/luca/feature'
+import { type AvailableFeatures } from 'luca/feature'
 import { Feature } from '../feature.js'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
   interface AvailableFeatures {
     claudeCode: typeof ClaudeCode
   }
@@ -184,6 +184,12 @@ export const ClaudeCodeOptionsSchema = FeatureOptionsSchema.extend({
   skillsFolders: z.array(z.string()).optional().describe('Directories containing Claude Code skills to load into sessions'),
   /** Launch Claude Code with a Chrome browser tool. */
   chrome: z.boolean().optional().describe('Launch Claude Code with a Chrome browser tool'),
+  /** Base URL for the Anthropic API. Injected as ANTHROPIC_BASE_URL env var. */
+  baseURL: z.string().optional().describe('Base URL for the Anthropic API, injected as ANTHROPIC_BASE_URL'),
+  /** Auth token for the Anthropic API. Injected as ANTHROPIC_AUTH_TOKEN env var. */
+  authToken: z.string().optional().describe('Auth token for the Anthropic API, injected as ANTHROPIC_AUTH_TOKEN'),
+  /** Use local models. Sets baseURL and model from LOCAL_CHAT_ENDPOINT and LOCAL_CODER_MODEL env vars. */
+  local: z.boolean().optional().describe('Use local models, sets baseURL to LOCAL_CHAT_ENDPOINT and model to LOCAL_CODER_MODEL'),
 })
 
 export const ClaudeCodeEventsSchema = FeatureEventsSchema.extend({
@@ -269,6 +275,12 @@ export interface RunOptions {
   settingsFile?: string
   /** Launch Claude Code with a Chrome browser tool. */
   chrome?: boolean
+  /** Base URL for the Anthropic API. Injected as ANTHROPIC_BASE_URL in the subprocess env. */
+  baseURL?: string
+  /** Auth token for the Anthropic API. Injected as ANTHROPIC_AUTH_TOKEN in the subprocess env. */
+  authToken?: string
+  /** Use local models. Sets baseURL to LOCAL_CHAT_ENDPOINT (or http://localhost:1234) and model to LOCAL_CODER_MODEL (or qwen/qwen3.6-27b). */
+  local?: boolean
 }
 
 /**
@@ -506,7 +518,8 @@ export class ClaudeCode extends Feature<ClaudeCodeState, ClaudeCodeOptions> {
       args.push('--include-partial-messages')
     }
 
-    const model = options.model ?? this.options.model
+    const isLocal = options.local ?? this.options.local
+    const model = options.model ?? this.options.model ?? (isLocal ? (process.env.LOCAL_CODER_MODEL || 'qwen/qwen3.6-27b') : undefined)
     if (model) args.push('--model', model)
 
     const systemPrompt = options.systemPrompt ?? this.options.systemPrompt
@@ -613,6 +626,39 @@ export class ClaudeCode extends Feature<ClaudeCodeState, ClaudeCodeOptions> {
     return args
   }
 
+  /**
+   * Build the environment object for a claude CLI invocation.
+   * Injects ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN when baseURL/authToken are set,
+   * or when local mode is enabled.
+   *
+   * @param {RunOptions} options - Session options
+   * @returns {Record<string, string>} Environment variables
+   */
+  private buildEnv(options: RunOptions = {}): Record<string, string> {
+    const env = { ...process.env }
+    const isLocal = options.local ?? this.options.local
+
+    if (isLocal) {
+      const baseURL = process.env.LOCAL_CHAT_ENDPOINT || 'http://localhost:1234'
+      env.ANTHROPIC_BASE_URL = baseURL
+      if (!options.authToken) {
+        env.ANTHROPIC_AUTH_TOKEN = process.env.LOCAL_CHAT_AUTH_TOKEN || 'sk-anticropic-00000000000000000000001'
+      }
+    }
+
+    const baseURL = options.baseURL
+    if (baseURL) {
+      env.ANTHROPIC_BASE_URL = baseURL
+    }
+
+    const authToken = options.authToken
+    if (authToken) {
+      env.ANTHROPIC_AUTH_TOKEN = authToken
+    }
+
+    return env
+  }
+
   /**
    * Create a unique session ID.
    *
@@ -780,7 +826,7 @@ export class ClaudeCode extends Feature<ClaudeCodeState, ClaudeCodeOptions> {
       stdout: 'pipe',
       stderr: 'pipe',
       stdin: Buffer.from(prompt),
-      environment: { ...process.env },
+      environment: this.buildEnv(options),
     })
 
     this.updateSession(id, { process: proc })
@@ -842,7 +888,7 @@ export class ClaudeCode extends Feature<ClaudeCodeState, ClaudeCodeOptions> {
       stdout: 'pipe',
       stderr: 'pipe',
       stdin: Buffer.from(prompt),
-      environment: { ...process.env },
+      environment: this.buildEnv(options),
     })
 
     this.updateSession(id, { process: proc })

package/src/agi/features/coding-tools.ts

@@ -4,7 +4,7 @@ import { Feature } from '../feature.js'
 import type { Helper } from '../../helper.js'
 import type { ChildProcess } from '../../node/features/proc.js'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
 	interface AvailableFeatures {
 		codingTools: typeof CodingTools
 	}

package/src/agi/features/conversation-history.ts

@@ -1,16 +1,31 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { type AvailableFeatures } from '@soederpop/luca/feature'
+import { type AvailableFeatures } from 'luca/feature'
 import { Feature } from '../feature.js'
-import type { DiskCache } from '@soederpop/luca/node/container'
+import type { DiskCache } from 'luca/node/container'
+import type { OpenAIClient } from '../../clients/openai'
 import type { Message } from './conversation'
 
-declare module '@soederpop/luca/feature' {
+declare module 'luca/feature' {
 	interface AvailableFeatures {
 		conversationHistory: typeof ConversationHistory
 	}
 }
 
+export interface TokenUsage {
+	prompt: number
+	completion: number
+	total: number
+	cachedTokens?: number
+	reasoningTokens?: number
+}
+
+export interface CostInfo {
+	inputCost: number
+	outputCost: number
+	totalCost: number
+}
+
 export interface ConversationRecord {
 	id: string
 	title: string
@@ -21,6 +36,8 @@ export interface ConversationRecord {
 	createdAt: string
 	updatedAt: string
 	messageCount: number
+	tokenUsage?: TokenUsage
+	cost?: CostInfo
 	metadata: Record<string, any>
 }
 
@@ -160,12 +177,15 @@ export class ConversationHistory extends Feature<ConversationHistoryState, Conve
 		messages: Message[]
 		tags?: string[]
 		thread?: string
+		tokenUsage?: TokenUsage
+		cost?: CostInfo
 		metadata?: Record<string, any>
 	}): Promise<ConversationRecord> {
 		const now = new Date().toISOString()
+		const title = opts.title || await this.autoTitle(opts.messages)
 		const record: ConversationRecord = {
 			id: opts.id || crypto.randomUUID(),
-			title: opts.title || 'Untitled',
+			title,
 			model: opts.model || 'unknown',
 			messages: opts.messages,
 			tags: opts.tags || [],
@@ -173,6 +193,8 @@ export class ConversationHistory extends Feature<ConversationHistoryState, Conve
 			createdAt: now,
 			updatedAt: now,
 			messageCount: opts.messages.length,
+			tokenUsage: opts.tokenUsage,
+			cost: opts.cost,
 			metadata: opts.metadata || {},
 		}
 
@@ -408,6 +430,161 @@ export class ConversationHistory extends Feature<ConversationHistoryState, Conve
 		return count
 	}
 
+	/** @returns An OpenAI client from the container for LLM calls. */
+	private get openai(): OpenAIClient {
+		return (this.container as any).client('openai') as OpenAIClient
+	}
+
+	/**
+	 * Generate a short title from conversation messages. Uses the first user
+	 * message (and optionally the first assistant reply) to produce a concise
+	 * title via a cheap LLM call. Falls back to a truncated first message
+	 * if the LLM call fails.
+	 */
+	private async autoTitle(messages: Message[]): Promise<string> {
+		const userMsg = messages.find(m => m.role === 'user')
+		if (!userMsg) return `Conversation ${new Date().toISOString().slice(0, 16)}`
+
+		const userContent = typeof userMsg.content === 'string'
+			? userMsg.content
+			: Array.isArray(userMsg.content)
+				? (userMsg.content as any[]).filter((p: any) => p.type === 'text').map((p: any) => p.text).join(' ')
+				: ''
+
+		if (!userContent.trim()) return `Conversation ${new Date().toISOString().slice(0, 16)}`
+
+		// Build a small context snippet: first user message + first assistant reply if available
+		const assistantMsg = messages.find(m => m.role === 'assistant')
+		let context = `User: ${userContent}`
+		if (assistantMsg) {
+			const assistantContent = typeof assistantMsg.content === 'string'
+				? assistantMsg.content
+				: Array.isArray(assistantMsg.content)
+					? (assistantMsg.content as any[]).filter((p: any) => p.type === 'text').map((p: any) => p.text).join(' ')
+					: ''
+			if (assistantContent.trim()) {
+				context += `\nAssistant: ${assistantContent.slice(0, 300)}`
+			}
+		}
+
+		try {
+			const response = await this.openai.raw.chat.completions.create({
+				model: 'gpt-4o-mini',
+				messages: [
+					{
+						role: 'system',
+						content: 'Generate a short title (max 8 words) for this conversation. Output only the title, no quotes or punctuation wrapping.',
+					},
+					{ role: 'user', content: context.slice(0, 1000) },
+				],
+				max_tokens: 30,
+				temperature: 0.3,
+				stream: false,
+			})
+
+			const title = (response as any).choices?.[0]?.message?.content?.trim()
+			if (title) return title
+		} catch {
+			// LLM unavailable — fall back to truncation
+		}
+
+		// Fallback: truncate the first user message
+		return userContent.length > 60 ? userContent.slice(0, 57) + '...' : userContent
+	}
+
+	/**
+	 * Build a plain-text transcript from a messages array,
+	 * suitable for feeding to a summarizer or title generator.
+	 */
+	private buildTranscript(messages: Message[]): string {
+		return messages
+			.map(m => {
+				const role = m.role
+				const content = typeof m.content === 'string'
+					? m.content
+					: Array.isArray(m.content)
+						? (m.content as any[]).filter((p: any) => p.type === 'text').map((p: any) => p.text).join('\n')
+						: (m.content != null ? JSON.stringify(m.content) : '(no content)')
+				return `[${role}]: ${content || '(no text content)'}`
+			})
+			.join('\n\n')
+	}
+
+	/**
+	 * Generate a concise summary of a stored conversation using the LLM.
+	 * The summary is stored in `metadata.summary` and returned.
+	 * No tool calls are made — this is a single completion request.
+	 *
+	 * @param {string} id - The conversation ID to summarize
+	 * @param {object} [options] - Optional settings
+	 * @param {string} [options.model] - Override the model used for summarization
+	 * @returns {Promise<string | null>} The generated summary, or null if conversation not found
+	 */
+	async summarize(id: string, options?: { model?: string }): Promise<string | null> {
+		const record = await this.load(id)
+		if (!record) return null
+
+		const transcript = this.buildTranscript(record.messages)
+		const model = options?.model || record.model || 'gpt-5'
+
+		const response = await this.openai.raw.chat.completions.create({
+			model,
+			messages: [
+				{
+					role: 'system',
+					content: 'You are a conversation summarizer. Produce a concise but comprehensive summary of the following conversation. Preserve all key facts, decisions, context, user preferences, and any important details needed to understand what was discussed. Output only the summary.',
+				},
+				{ role: 'user', content: transcript },
+			],
+			stream: false,
+		})
+
+		const summary = (response as any).choices?.[0]?.message?.content || ''
+
+		record.metadata = { ...record.metadata, summary }
+		await this.save(record)
+
+		return summary
+	}
+
+	/**
+	 * Generate a short, descriptive title for a stored conversation using the LLM.
+	 * The title is stored both as the record's `title` field and in `metadata.generatedTitle`,
+	 * then returned. No tool calls are made.
+	 *
+	 * @param {string} id - The conversation ID to generate a title for
+	 * @param {object} [options] - Optional settings
+	 * @param {string} [options.model] - Override the model used for title generation
+	 * @returns {Promise<string | null>} The generated title, or null if conversation not found
+	 */
+	async generateTitle(id: string, options?: { model?: string }): Promise<string | null> {
+		const record = await this.load(id)
+		if (!record) return null
+
+		const transcript = this.buildTranscript(record.messages)
+		const model = options?.model || record.model || 'gpt-5'
+
+		const response = await this.openai.raw.chat.completions.create({
+			model,
+			messages: [
+				{
+					role: 'system',
+					content: 'Generate a short, descriptive title (under 60 characters) for the following conversation. The title should capture the main topic or purpose. Output only the title text, with no quotes or punctuation wrapping it.',
+				},
+				{ role: 'user', content: transcript },
+			],
+			stream: false,
+		})
+
+		const title = ((response as any).choices?.[0]?.message?.content || '').trim()
+
+		record.title = title
+		record.metadata = { ...record.metadata, generatedTitle: title }
+		await this.save(record)
+
+		return title
+	}
+
 	// -- index management --
 
 	private async getIndex(): Promise<string[]> {