@ottocode/server 0.1.173

package/src/runtime/message/service.ts

@@ -0,0 +1,468 @@
+import { generateText, streamText } from 'ai';
+import { eq, asc } from 'drizzle-orm';
+import type { OttoConfig } from '@ottocode/sdk';
+import type { DB } from '@ottocode/database';
+import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { publish } from '../../events/bus.ts';
+import { enqueueAssistantRun } from '../session/queue.ts';
+import { runSessionLoop } from '../agent/runner.ts';
+import { resolveModel } from '../provider/index.ts';
+import { getFastModelForAuth, type ProviderId } from '@ottocode/sdk';
+import { debugLog } from '../debug/index.ts';
+import { isCompactCommand, buildCompactionContext } from './compaction.ts';
+import { detectOAuth, adaptSimpleCall } from '../provider/oauth-adapter.ts';
+
+type SessionRow = typeof sessions.$inferSelect;
+
+type DispatchOptions = {
+	cfg: OttoConfig;
+	db: DB;
+	session: SessionRow;
+	agent: string;
+	provider: ProviderId;
+	model: string;
+	content: string;
+	oneShot?: boolean;
+	userContext?: string;
+	reasoningText?: boolean;
+	images?: Array<{ data: string; mediaType: string }>;
+	files?: Array<{
+		type: 'image' | 'pdf' | 'text';
+		name: string;
+		data: string;
+		mediaType: string;
+		textContent?: string;
+	}>;
+};
+
+export async function dispatchAssistantMessage(
+	options: DispatchOptions,
+): Promise<{ assistantMessageId: string }> {
+	const {
+		cfg,
+		db,
+		session,
+		agent,
+		provider,
+		model,
+		content,
+		oneShot,
+		userContext,
+		reasoningText,
+		images,
+		files,
+	} = options;
+
+	debugLog(
+		`[MESSAGE_SERVICE] dispatchAssistantMessage called with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
+	);
+
+	const sessionId = session.id;
+	const now = Date.now();
+	const userMessageId = crypto.randomUUID();
+
+	await db.insert(messages).values({
+		id: userMessageId,
+		sessionId,
+		role: 'user',
+		status: 'complete',
+		agent,
+		provider,
+		model,
+		createdAt: now,
+	});
+	await db.insert(messageParts).values({
+		id: crypto.randomUUID(),
+		messageId: userMessageId,
+		index: 0,
+		type: 'text',
+		content: JSON.stringify({ text: String(content) }),
+		agent,
+		provider,
+		model,
+	});
+
+	if (images && images.length > 0) {
+		for (let i = 0; i < images.length; i++) {
+			const img = images[i];
+			await db.insert(messageParts).values({
+				id: crypto.randomUUID(),
+				messageId: userMessageId,
+				index: i + 1,
+				type: 'image',
+				content: JSON.stringify({ data: img.data, mediaType: img.mediaType }),
+				agent,
+				provider,
+				model,
+			});
+		}
+	}
+
+	let nextIndex = (images?.length ?? 0) + 1;
+	if (files && files.length > 0) {
+		for (const file of files) {
+			const partType = file.type === 'image' ? 'image' : 'file';
+			await db.insert(messageParts).values({
+				id: crypto.randomUUID(),
+				messageId: userMessageId,
+				index: nextIndex++,
+				type: partType,
+				content: JSON.stringify({
+					type: file.type,
+					name: file.name,
+					data: file.data,
+					mediaType: file.mediaType,
+					textContent: file.textContent,
+				}),
+				agent,
+				provider,
+				model,
+			});
+		}
+	}
+
+	publish({
+		type: 'message.created',
+		sessionId,
+		payload: { id: userMessageId, role: 'user' },
+	});
+
+	const assistantMessageId = crypto.randomUUID();
+	await db.insert(messages).values({
+		id: assistantMessageId,
+		sessionId,
+		role: 'assistant',
+		status: 'pending',
+		agent,
+		provider,
+		model,
+		createdAt: Date.now(),
+	});
+	publish({
+		type: 'message.created',
+		sessionId,
+		payload: { id: assistantMessageId, role: 'assistant' },
+	});
+
+	debugLog(
+		`[MESSAGE_SERVICE] Enqueuing assistant run with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
+	);
+
+	const isCompact = isCompactCommand(content);
+	let compactionContext: string | undefined;
+
+	if (isCompact) {
+		debugLog('[MESSAGE_SERVICE] Detected /compact command, building context');
+		const { getModelLimits } = await import('./compaction.ts');
+		const limits = getModelLimits(provider, model);
+		const contextTokenLimit = limits
+			? Math.max(Math.floor(limits.context * 0.5), 15000)
+			: 15000;
+		compactionContext = await buildCompactionContext(
+			db,
+			sessionId,
+			contextTokenLimit,
+		);
+		debugLog(
+			`[message-service] /compact context length: ${compactionContext.length}, limit: ${contextTokenLimit} tokens`,
+		);
+	}
+
+	const toolApprovalMode = cfg.defaults.toolApproval ?? 'auto';
+
+	enqueueAssistantRun(
+		{
+			sessionId,
+			assistantMessageId,
+			agent,
+			provider,
+			model,
+			projectRoot: cfg.projectRoot,
+			oneShot: Boolean(oneShot),
+			userContext,
+			reasoningText,
+			isCompactCommand: isCompact,
+			compactionContext,
+			toolApprovalMode,
+		},
+		runSessionLoop,
+	);
+
+	void touchSessionLastActive({ db, sessionId });
+
+	return { assistantMessageId };
+}
+
+const TITLE_CONCURRENCY_LIMIT = 1;
+const titleQueue: Array<() => void> = [];
+let titleActiveCount = 0;
+const titleInFlight = new Set<string>();
+const titlePending = new Set<string>();
+
+function scheduleSessionTitle(args: {
+	cfg: OttoConfig;
+	db: DB;
+	sessionId: string;
+	content: unknown;
+}) {
+	const { cfg, db, sessionId, content } = args;
+
+	if (titleInFlight.has(sessionId) || titlePending.has(sessionId)) {
+		return;
+	}
+
+	const processNext = () => {
+		if (titleQueue.length === 0) {
+			return;
+		}
+		if (titleActiveCount >= TITLE_CONCURRENCY_LIMIT) {
+			return;
+		}
+		const next = titleQueue.shift();
+		if (!next) return;
+		titleActiveCount++;
+		next();
+	};
+
+	const task = async () => {
+		titleInFlight.add(sessionId);
+		titlePending.delete(sessionId);
+		try {
+			await generateSessionTitle({ cfg, db, sessionId, content });
+		} catch (err) {
+			debugLog('[TITLE_GEN] Title generation error:');
+			debugLog(err);
+		} finally {
+			titleInFlight.delete(sessionId);
+			titleActiveCount--;
+			processNext();
+		}
+	};
+
+	titlePending.add(sessionId);
+	titleQueue.push(task);
+	processNext();
+}
+
+function enqueueSessionTitle(args: {
+	cfg: OttoConfig;
+	db: DB;
+	sessionId: string;
+	content: unknown;
+}) {
+	scheduleSessionTitle(args);
+}
+
+async function generateSessionTitle(args: {
+	cfg: OttoConfig;
+	db: DB;
+	sessionId: string;
+	content: unknown;
+}): Promise<void> {
+	const { cfg, db, sessionId, content } = args;
+
+	try {
+		const existingSession = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, sessionId));
+
+		if (!existingSession.length) {
+			debugLog('[TITLE_GEN] Session not found, aborting');
+			return;
+		}
+
+		const sess = existingSession[0];
+		if (sess.title && sess.title !== 'New Session') {
+			debugLog('[TITLE_GEN] Session already has a title, skipping');
+			return;
+		}
+
+		const provider = sess.provider ?? cfg.defaults.provider;
+		const modelName = sess.model ?? cfg.defaults.model;
+
+		debugLog('[TITLE_GEN] Generating title for session');
+		debugLog(`[TITLE_GEN] Provider: ${provider}, Model: ${modelName}`);
+
+		const { getAuth } = await import('@ottocode/sdk');
+		const auth = await getAuth(provider, cfg.projectRoot);
+		const oauth = detectOAuth(provider, auth);
+
+		const titleModel = getFastModelForAuth(provider, auth?.type) ?? modelName;
+		debugLog(`[TITLE_GEN] Using title model: ${titleModel}`);
+		const model = await resolveModel(provider, titleModel, cfg);
+
+		debugLog(
+			`[TITLE_GEN] oauth: needsSpoof=${oauth.needsSpoof}, isOpenAIOAuth=${oauth.isOpenAIOAuth}`,
+		);
+
+		const promptText = String(content ?? '').slice(0, 2000);
+
+		const titleInstructions = `Generate a brief title (6-8 words) summarizing what the user wants to do.
+Rules: Plain text only. No markdown, no quotes, no punctuation, no emojis.
+Focus on the core task or topic. Be specific but concise.
+Examples: "Fix TypeScript build errors", "Add dark mode toggle", "Refactor auth middleware"
+
+Output ONLY the title, nothing else.`;
+
+		const adapted = adaptSimpleCall(oauth, {
+			instructions: titleInstructions,
+			userContent: promptText,
+		});
+
+		debugLog(
+			`[TITLE_GEN] mode=${adapted.forceStream ? 'openai-oauth' : oauth.needsSpoof ? 'spoof' : 'api-key'}`,
+		);
+
+		let modelTitle = '';
+		try {
+			if (adapted.forceStream || oauth.needsSpoof) {
+				const result = streamText({
+					model,
+					system: adapted.system,
+					messages: adapted.messages,
+					providerOptions: adapted.providerOptions,
+				});
+				for await (const chunk of result.textStream) {
+					modelTitle += chunk;
+				}
+				modelTitle = modelTitle.trim();
+			} else {
+				debugLog('[TITLE_GEN] Using generateText...');
+				const out = await generateText({
+					model,
+					system: adapted.system,
+					messages: adapted.messages,
+				});
+				modelTitle = (out?.text || '').trim();
+			}
+
+			debugLog('[TITLE_GEN] Raw response from model:');
+			debugLog(`[TITLE_GEN] "${modelTitle}"`);
+		} catch (err) {
+			debugLog('[TITLE_GEN] Error generating title:');
+			debugLog(err);
+		}
+
+		if (!modelTitle) {
+			debugLog('[TITLE_GEN] No title returned, aborting');
+			return;
+		}
+
+		const sanitized = sanitizeTitle(modelTitle);
+		debugLog(`[TITLE_GEN] After sanitization: "${sanitized}"`);
+
+		if (!sanitized || sanitized === 'New Session') {
+			debugLog('[TITLE_GEN] Sanitized title is empty or default, aborting');
+			return;
+		}
+
+		await db
+			.update(sessions)
+			.set({ title: sanitized, updatedAt: Date.now() })
+			.where(eq(sessions.id, sessionId));
+
+		debugLog(`[TITLE_GEN] Setting final title: "${sanitized}"`);
+
+		publish({
+			type: 'session.updated',
+			sessionId,
+			payload: { id: sessionId, title: sanitized },
+		});
+	} catch (err) {
+		debugLog('[TITLE_GEN] Error in generateSessionTitle:');
+		debugLog(err);
+	}
+}
+
+function sanitizeTitle(raw: string): string {
+	let s = raw.trim();
+	s = s.replace(/^#+\s*/, '');
+	s = s.replace(/\*\*([^*]+)\*\*/g, '$1');
+	s = s.replace(/\*([^*]+)\*/g, '$1');
+	s = s.replace(/__([^_]+)__/g, '$1');
+	s = s.replace(/_([^_]+)_/g, '$1');
+	s = s.replace(/`([^`]+)`/g, '$1');
+	s = s.replace(/~~([^~]+)~~/g, '$1');
+	s = s.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+	s = s.replace(/^["']|["']$/g, '');
+	s = s.replace(/^[-–—•*]\s*/, '');
+	s = s.replace(/[.!?:;,]+$/, '');
+	s = s.replace(/\s+/g, ' ');
+	if (s.length > 80) s = s.slice(0, 80).trim();
+	return s;
+}
+
+async function touchSessionLastActive(args: {
+	db: DB;
+	sessionId: string;
+}): Promise<void> {
+	const { db, sessionId } = args;
+	try {
+		await db
+			.update(sessions)
+			.set({ lastActiveAt: Date.now() })
+			.where(eq(sessions.id, sessionId))
+			.run();
+	} catch (err) {
+		debugLog('[touchSessionLastActive] Error:', err);
+	}
+}
+
+export async function triggerDeferredTitleGeneration(args: {
+	cfg: OttoConfig;
+	db: DB;
+	sessionId: string;
+}): Promise<void> {
+	const { cfg, db, sessionId } = args;
+
+	try {
+		const userMessages = await db
+			.select()
+			.from(messages)
+			.where(eq(messages.sessionId, sessionId))
+			.orderBy(asc(messages.createdAt))
+			.limit(1);
+
+		if (!userMessages.length || userMessages[0].role !== 'user') {
+			debugLog(
+				'[TITLE_GEN] No user message found for deferred title generation',
+			);
+			return;
+		}
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, userMessages[0].id))
+			.orderBy(asc(messageParts.index))
+			.limit(1);
+
+		if (!parts.length) {
+			debugLog(
+				'[TITLE_GEN] No message parts found for deferred title generation',
+			);
+			return;
+		}
+
+		let content = '';
+		try {
+			const parsed = JSON.parse(parts[0].content ?? '{}');
+			content = String(parsed.text ?? '');
+		} catch {
+			debugLog('[TITLE_GEN] Failed to parse message part content');
+			return;
+		}
+
+		if (!content) {
+			debugLog('[TITLE_GEN] Empty content for deferred title generation');
+			return;
+		}
+
+		debugLog('[TITLE_GEN] Triggering deferred title generation');
+		enqueueSessionTitle({ cfg, db, sessionId, content });
+	} catch (err) {
+		debugLog('[TITLE_GEN] Error in triggerDeferredTitleGeneration:');
+		debugLog(err);
+	}
+}

package/src/runtime/message/tool-history-tracker.ts

@@ -0,0 +1,204 @@
+import { debugLog } from '../debug/index.ts';
+
+type ToolResultPart = {
+	type: string;
+	state?: string;
+	toolCallId?: string;
+	input?: unknown;
+	output?: unknown;
+	[key: string]: unknown;
+};
+
+type ToolResultInfo = {
+	toolName: string;
+	callId: string;
+	args: unknown;
+	result: unknown;
+};
+
+type TargetDescriptor = {
+	keys: string[];
+	summary: string;
+};
+
+type TrackedPart = {
+	part: ToolResultPart;
+	summary: string;
+	summarized: boolean;
+};
+
+export class ToolHistoryTracker {
+	private readonly targets = new Map<string, TrackedPart>();
+
+	register(part: ToolResultPart, info: ToolResultInfo) {
+		const descriptor = describeToolResult(info);
+		if (!descriptor) return;
+
+		const entry: TrackedPart = {
+			part,
+			summary: descriptor.summary,
+			summarized: false,
+		};
+
+		for (const key of descriptor.keys) {
+			const previous = this.targets.get(key);
+			if (previous && previous.part !== part) {
+				this.applySummary(previous);
+			}
+			this.targets.set(key, entry);
+		}
+	}
+
+	private applySummary(entry: TrackedPart) {
+		if (entry.summarized) return;
+		// Keep this entry as a tool result so the history still produces tool_result blocks.
+		entry.part.state = 'output-available';
+		entry.part.output = entry.summary;
+		(entry.part as { summaryText?: string }).summaryText = entry.summary;
+		delete (entry.part as { errorText?: unknown }).errorText;
+		delete (entry.part as { rawInput?: unknown }).rawInput;
+		delete (entry.part as { callProviderMetadata?: unknown })
+			.callProviderMetadata;
+		delete (entry.part as { providerMetadata?: unknown }).providerMetadata;
+		entry.summarized = true;
+		debugLog(`[history] summarized tool output -> ${entry.summary}`);
+	}
+}
+
+function describeToolResult(info: ToolResultInfo): TargetDescriptor | null {
+	const { toolName } = info;
+	switch (toolName) {
+		case 'read':
+			return describeRead(info);
+		case 'glob':
+		case 'grep':
+			return describePatternTool(info, toolName);
+		case 'write':
+			return describeWrite(info);
+		case 'apply_patch':
+			return describePatch(info);
+		default:
+			return null;
+	}
+}
+
+function describeRead(info: ToolResultInfo): TargetDescriptor | null {
+	const args = getRecord(info.args);
+	if (!args) return null;
+	const path = getString(args.path);
+	if (!path) return null;
+	const startLine = getNumber(args.startLine);
+	const endLine = getNumber(args.endLine);
+
+	let rangeLabel = 'entire file';
+	let rangeKey = 'all';
+	if (startLine !== undefined || endLine !== undefined) {
+		const start = startLine ?? 1;
+		const end = endLine ?? 'end';
+		rangeLabel = `lines ${start}–${end}`;
+		rangeKey = `${start}-${end}`;
+	}
+
+	const key = `read:${normalizePath(path)}:${rangeKey}`;
+	const summary = `[previous read] ${normalizePath(path)} (${rangeLabel})`;
+	return { keys: [key], summary };
+}
+
+function describePatternTool(
+	info: ToolResultInfo,
+	toolName: string,
+): TargetDescriptor | null {
+	const args = getRecord(info.args);
+	if (!args) return null;
+	const pattern =
+		getString(args.pattern) ??
+		getString(args.filePattern) ??
+		getString(args.path);
+	if (!pattern) return null;
+	const key = `${toolName}:${pattern}`;
+	const summary = `[previous ${toolName}] ${pattern}`;
+	return { keys: [key], summary };
+}
+
+function describeWrite(info: ToolResultInfo): TargetDescriptor | null {
+	const result = getRecord(info.result);
+	if (!result) return null;
+	const path = getString(result.path);
+	if (!path) return null;
+	const bytes = getNumber(result.bytes);
+	const sizeLabel =
+		typeof bytes === 'number' && Number.isFinite(bytes)
+			? `${bytes} bytes`
+			: 'unknown size';
+	const key = `write:${normalizePath(path)}`;
+	const summary = `[previous write] ${normalizePath(path)} (${sizeLabel})`;
+	return { keys: [key], summary };
+}
+
+function describePatch(info: ToolResultInfo): TargetDescriptor | null {
+	const result = getRecord(info.result);
+	if (!result) return null;
+
+	const files = new Set<string>();
+
+	const changes = getArray(result.changes);
+	if (changes) {
+		for (const change of changes) {
+			const changeObj = getRecord(change);
+			const filePath = changeObj && getString(changeObj.filePath);
+			if (filePath) files.add(normalizePath(filePath));
+		}
+	}
+
+	const artifact = getRecord(result.artifact);
+	if (artifact) {
+		const summary = getRecord(artifact.summary);
+		const summaryFiles = getArray(summary?.files);
+		if (summaryFiles) {
+			for (const item of summaryFiles) {
+				if (typeof item === 'string') files.add(normalizePath(item));
+				else {
+					const record = getRecord(item);
+					const value = record && getString(record.path);
+					if (value) files.add(normalizePath(value));
+				}
+			}
+		}
+	}
+
+	const fileList = Array.from(files);
+	const keys = fileList.length
+		? fileList.map((file) => `apply_patch:${file}`)
+		: [`apply_patch:${info.callId}`];
+
+	const summary =
+		fileList.length > 0
+			? `[previous patch] ${fileList.join(', ')}`
+			: '[previous patch] (unknown files)';
+
+	return { keys, summary };
+}
+
+function getRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === 'object' && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+function getArray(value: unknown): unknown[] | null {
+	return Array.isArray(value) ? value : null;
+}
+
+function getString(value: unknown): string | null {
+	if (typeof value === 'string') return value;
+	return null;
+}
+
+function getNumber(value: unknown): number | undefined {
+	if (typeof value === 'number' && Number.isFinite(value)) return value;
+	return undefined;
+}
+
+function normalizePath(path: string): string {
+	return path.replace(/\\/g, '/');
+}