@ottocode/server 0.1.173

package/src/runtime/provider/setu.ts

@@ -0,0 +1,126 @@
+import {
+	createSetuModel,
+	catalog,
+	type SetuPaymentCallbacks,
+	getAuth,
+	loadConfig,
+} from '@ottocode/sdk';
+import { publish } from '../../events/bus.ts';
+import {
+	waitForTopupMethodSelection,
+	type TopupMethod,
+} from '../topup/manager.ts';
+
+const MIN_TOPUP_USD = 5;
+
+function getProviderNpm(model: string): string | undefined {
+	const entry = catalog.setu?.models?.find((m) => m.id === model);
+	return entry?.provider?.npm;
+}
+
+export interface ResolveSetuModelOptions {
+	messageId?: string;
+	topupApprovalMode?: 'auto' | 'approval';
+}
+
+async function getSetuPrivateKey(): Promise<string> {
+	if (process.env.SETU_PRIVATE_KEY) {
+		return process.env.SETU_PRIVATE_KEY;
+	}
+	try {
+		const cfg = await loadConfig(process.cwd());
+		const auth = await getAuth('setu', cfg.projectRoot);
+		if (auth?.type === 'wallet' && auth.secret) {
+			return auth.secret;
+		}
+	} catch {}
+	return '';
+}
+
+export async function resolveSetuModel(
+	model: string,
+	sessionId?: string,
+	options: ResolveSetuModelOptions = {},
+) {
+	const privateKey = await getSetuPrivateKey();
+	if (!privateKey) {
+		throw new Error(
+			'Setu provider requires SETU_PRIVATE_KEY (base58 Solana secret).',
+		);
+	}
+	const baseURL = process.env.SETU_BASE_URL;
+	const rpcURL = process.env.SETU_SOLANA_RPC_URL;
+	const { messageId, topupApprovalMode = 'approval' } = options;
+
+	const callbacks: SetuPaymentCallbacks = sessionId
+		? {
+				onPaymentRequired: (amountUsd, currentBalance) => {
+					publish({
+						type: 'setu.payment.required',
+						sessionId,
+						payload: { amountUsd, currentBalance },
+					});
+				},
+				onPaymentSigning: () => {
+					publish({
+						type: 'setu.payment.signing',
+						sessionId,
+						payload: {},
+					});
+				},
+				onPaymentComplete: (data) => {
+					publish({
+						type: 'setu.payment.complete',
+						sessionId,
+						payload: data,
+					});
+				},
+				onPaymentError: (error) => {
+					publish({
+						type: 'setu.payment.error',
+						sessionId,
+						payload: { error },
+					});
+				},
+				onPaymentApproval: async (info): Promise<TopupMethod | 'cancel'> => {
+					const suggestedTopupUsd = Math.max(
+						MIN_TOPUP_USD,
+						Math.ceil(info.amountUsd * 2),
+					);
+
+					publish({
+						type: 'setu.topup.required',
+						sessionId,
+						payload: {
+							messageId,
+							amountUsd: info.amountUsd,
+							currentBalance: info.currentBalance,
+							minTopupUsd: MIN_TOPUP_USD,
+							suggestedTopupUsd,
+						},
+					});
+
+					return waitForTopupMethodSelection(
+						sessionId,
+						messageId ?? '',
+						info.amountUsd,
+						info.currentBalance,
+					);
+				},
+			}
+		: {};
+
+	const providerNpm = getProviderNpm(model);
+
+	return createSetuModel(
+		model,
+		{ privateKey },
+		{
+			baseURL,
+			rpcURL,
+			callbacks,
+			providerNpm,
+			topupApprovalMode,
+		},
+	);
+}

package/src/runtime/provider/zai.ts

@@ -0,0 +1,16 @@
+import type { OttoConfig } from '@ottocode/sdk';
+import { getAuth, createZaiModel, createZaiCodingModel } from '@ottocode/sdk';
+
+export async function getZaiInstance(cfg: OttoConfig, model: string) {
+	const auth = await getAuth('zai', cfg.projectRoot);
+	const apiKey = auth?.type === 'api' ? auth.key : undefined;
+	return createZaiModel(model, { apiKey });
+}
+
+export async function getZaiCodingInstance(cfg: OttoConfig, model: string) {
+	const auth =
+		(await getAuth('zai', cfg.projectRoot)) ||
+		(await getAuth('zai-coding', cfg.projectRoot));
+	const apiKey = auth?.type === 'api' ? auth.key : undefined;
+	return createZaiCodingModel(model, { apiKey });
+}

package/src/runtime/session/branch.ts

@@ -0,0 +1,280 @@
+import { eq, asc } from 'drizzle-orm';
+import type { DB } from '@ottocode/database';
+import { sessions, messages, messageParts } from '@ottocode/database/schema';
+import { publish } from '../../events/bus.ts';
+import type { ProviderId } from '@ottocode/sdk';
+
+type SessionRow = typeof sessions.$inferSelect;
+
+export type CreateBranchInput = {
+	db: DB;
+	parentSessionId: string;
+	fromMessageId: string;
+	provider?: ProviderId;
+	model?: string;
+	agent?: string;
+	title?: string;
+	projectPath: string;
+};
+
+export type BranchResult = {
+	session: SessionRow;
+	parentSessionId: string;
+	branchPointMessageId: string;
+	copiedMessages: number;
+	copiedParts: number;
+};
+
+export async function createBranch({
+	db,
+	parentSessionId,
+	fromMessageId,
+	provider,
+	model,
+	agent,
+	title,
+	projectPath,
+}: CreateBranchInput): Promise<BranchResult> {
+	const parentRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, parentSessionId));
+
+	if (!parentRows.length) {
+		throw new Error('Parent session not found');
+	}
+
+	const parent = parentRows[0];
+
+	if (parent.projectPath !== projectPath) {
+		throw new Error('Parent session not found in this project');
+	}
+
+	const branchPointRows = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.id, fromMessageId));
+
+	if (!branchPointRows.length) {
+		throw new Error('Branch point message not found');
+	}
+
+	const branchPoint = branchPointRows[0];
+
+	if (branchPoint.sessionId !== parentSessionId) {
+		throw new Error('Branch point message does not belong to parent session');
+	}
+
+	const allMessages = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, parentSessionId))
+		.orderBy(asc(messages.createdAt));
+
+	const branchPointIndex = allMessages.findIndex((m) => m.id === fromMessageId);
+	if (branchPointIndex === -1) {
+		throw new Error('Branch point message not found in session');
+	}
+
+	const messagesToCopy = allMessages.slice(0, branchPointIndex + 1);
+
+	const newSessionId = crypto.randomUUID();
+	const now = Date.now();
+
+	const newSession: typeof sessions.$inferInsert = {
+		id: newSessionId,
+		title: title || `Branch of ${parent.title || 'Untitled'}`,
+		agent: agent || parent.agent,
+		provider: provider || parent.provider,
+		model: model || parent.model,
+		projectPath: parent.projectPath,
+		createdAt: now,
+		lastActiveAt: now,
+		parentSessionId,
+		branchPointMessageId: fromMessageId,
+		sessionType: 'branch',
+	};
+
+	await db.insert(sessions).values(newSession);
+
+	const messageIdMap = new Map<string, string>();
+	let copiedParts = 0;
+
+	for (const msg of messagesToCopy) {
+		const newMessageId = crypto.randomUUID();
+		messageIdMap.set(msg.id, newMessageId);
+
+		const newMessage: typeof messages.$inferInsert = {
+			id: newMessageId,
+			sessionId: newSessionId,
+			role: msg.role,
+			status: msg.status,
+			agent: msg.agent,
+			provider: msg.provider,
+			model: msg.model,
+			createdAt: msg.createdAt,
+			completedAt: msg.completedAt,
+			latencyMs: msg.latencyMs,
+			inputTokens: msg.inputTokens,
+			outputTokens: msg.outputTokens,
+			totalTokens: msg.totalTokens,
+			cachedInputTokens: msg.cachedInputTokens,
+			cacheCreationInputTokens: msg.cacheCreationInputTokens,
+			reasoningTokens: msg.reasoningTokens,
+			error: msg.error,
+			errorType: msg.errorType,
+			errorDetails: msg.errorDetails,
+			isAborted: msg.isAborted,
+		};
+
+		await db.insert(messages).values(newMessage);
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.orderBy(asc(messageParts.index));
+
+		for (const part of parts) {
+			const newPart: typeof messageParts.$inferInsert = {
+				id: crypto.randomUUID(),
+				messageId: newMessageId,
+				index: part.index,
+				stepIndex: part.stepIndex,
+				type: part.type,
+				content: part.content,
+				agent: part.agent,
+				provider: part.provider,
+				model: part.model,
+				startedAt: part.startedAt,
+				completedAt: part.completedAt,
+				compactedAt: part.compactedAt,
+				toolName: part.toolName,
+				toolCallId: part.toolCallId,
+				toolDurationMs: part.toolDurationMs,
+			};
+
+			await db.insert(messageParts).values(newPart);
+			copiedParts++;
+		}
+	}
+
+	const result: SessionRow = {
+		...newSession,
+		totalInputTokens: null,
+		totalOutputTokens: null,
+		totalCachedTokens: null,
+		totalCacheCreationTokens: null,
+		totalReasoningTokens: null,
+		totalToolTimeMs: null,
+		toolCountsJson: null,
+		currentContextTokens: null,
+		contextSummary: null,
+		lastCompactedAt: null,
+	};
+
+	publish({
+		type: 'session.created',
+		sessionId: newSessionId,
+		payload: result,
+	});
+
+	return {
+		session: result,
+		parentSessionId,
+		branchPointMessageId: fromMessageId,
+		copiedMessages: messagesToCopy.length,
+		copiedParts,
+	};
+}
+
+export type ListBranchesResult = Array<{
+	session: SessionRow;
+	branchPointMessageId: string | null;
+	branchPointPreview: string | null;
+	createdAt: number;
+}>;
+
+export async function listBranches(
+	db: DB,
+	sessionId: string,
+	projectPath: string,
+): Promise<ListBranchesResult> {
+	const branches = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.parentSessionId, sessionId))
+		.orderBy(asc(sessions.createdAt));
+
+	const results: ListBranchesResult = [];
+
+	for (const branch of branches) {
+		if (branch.projectPath !== projectPath) continue;
+
+		let preview: string | null = null;
+
+		if (branch.branchPointMessageId) {
+			const msgRows = await db
+				.select()
+				.from(messages)
+				.where(eq(messages.id, branch.branchPointMessageId));
+
+			if (msgRows.length > 0) {
+				const parts = await db
+					.select()
+					.from(messageParts)
+					.where(eq(messageParts.messageId, branch.branchPointMessageId))
+					.orderBy(asc(messageParts.index));
+
+				for (const part of parts) {
+					if (part.type === 'text') {
+						try {
+							const content = JSON.parse(part.content || '{}');
+							if (content.text) {
+								preview = content.text.slice(0, 100);
+								break;
+							}
+						} catch {}
+					}
+				}
+			}
+		}
+
+		results.push({
+			session: branch,
+			branchPointMessageId: branch.branchPointMessageId,
+			branchPointPreview: preview,
+			createdAt: branch.createdAt,
+		});
+	}
+
+	return results;
+}
+
+export async function getParentSession(
+	db: DB,
+	sessionId: string,
+	projectPath: string,
+): Promise<SessionRow | null> {
+	const sessionRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, sessionId));
+
+	if (!sessionRows.length) return null;
+
+	const session = sessionRows[0];
+	if (!session.parentSessionId) return null;
+
+	const parentRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, session.parentSessionId));
+
+	if (!parentRows.length) return null;
+
+	const parent = parentRows[0];
+	if (parent.projectPath !== projectPath) return null;
+
+	return parent;
+}

package/src/runtime/session/db-operations.ts

@@ -0,0 +1,285 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { catalog, type ProviderId } from '@ottocode/sdk';
+import type { RunOpts } from './queue.ts';
+
+export type UsageData = {
+	inputTokens?: number;
+	outputTokens?: number;
+	totalTokens?: number;
+	cachedInputTokens?: number;
+	cacheCreationInputTokens?: number;
+	reasoningTokens?: number;
+};
+
+export type ProviderMetadata = Record<string, unknown> & {
+	openai?: {
+		cachedPromptTokens?: number;
+		[key: string]: unknown;
+	};
+	anthropic?: {
+		cacheCreationInputTokens?: number;
+		cacheReadInputTokens?: number;
+		[key: string]: unknown;
+	};
+};
+
+export function normalizeUsage(
+	usage: UsageData,
+	providerOptions: ProviderMetadata | undefined,
+	provider: ProviderId,
+): UsageData {
+	const rawInputTokens = Number(usage.inputTokens ?? 0);
+	const outputTokens = Number(usage.outputTokens ?? 0);
+	const reasoningTokens = Number(usage.reasoningTokens ?? 0);
+
+	const cachedInputTokens =
+		usage.cachedInputTokens != null
+			? Number(usage.cachedInputTokens)
+			: providerOptions?.openai?.cachedPromptTokens != null
+				? Number(providerOptions.openai.cachedPromptTokens)
+				: providerOptions?.anthropic?.cacheReadInputTokens != null
+					? Number(providerOptions.anthropic.cacheReadInputTokens)
+					: undefined;
+
+	const cacheCreationInputTokens =
+		usage.cacheCreationInputTokens != null
+			? Number(usage.cacheCreationInputTokens)
+			: providerOptions?.anthropic?.cacheCreationInputTokens != null
+				? Number(providerOptions.anthropic.cacheCreationInputTokens)
+				: undefined;
+
+	const cachedValue = cachedInputTokens ?? 0;
+
+	let inputTokens = rawInputTokens;
+	if (provider === 'openai') {
+		inputTokens = Math.max(0, rawInputTokens - cachedValue);
+	}
+
+	return {
+		inputTokens,
+		outputTokens,
+		cachedInputTokens,
+		cacheCreationInputTokens,
+		reasoningTokens,
+	};
+}
+
+export function resolveUsageProvider(
+	provider: ProviderId,
+	model: string,
+): ProviderId {
+	if (
+		provider !== 'setu' &&
+		provider !== 'openrouter' &&
+		provider !== 'opencode'
+	) {
+		return provider;
+	}
+	const entry = catalog[provider];
+	const normalizedModel = model.includes('/') ? model.split('/').at(-1) : model;
+	const modelEntry = entry?.models.find(
+		(m) => m.id?.toLowerCase() === normalizedModel?.toLowerCase(),
+	);
+	const npm = modelEntry?.provider?.npm ?? '';
+	if (npm.includes('openai')) return 'openai';
+	if (npm.includes('anthropic')) return 'anthropic';
+	if (npm.includes('google')) return 'google';
+	if (npm.includes('zai')) return 'zai';
+	return provider;
+}
+
+/**
+ * Updates session token counts after each step.
+ * AI SDK v6: onStepFinish.usage is PER-STEP (each step = one API call).
+ * We ADD each step's tokens directly to session totals.
+ * We also track currentContextTokens = the latest step's full input context.
+ */
+export async function updateSessionTokensIncremental(
+	usage: UsageData,
+	providerOptions: ProviderMetadata | undefined,
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	if (!usage || !db) return;
+
+	const currentContextTokens = Number(usage.inputTokens ?? 0);
+
+	const usageProvider = resolveUsageProvider(opts.provider, opts.model);
+	const normalizedUsage = normalizeUsage(usage, providerOptions, usageProvider);
+
+	const stepInput = Number(normalizedUsage.inputTokens ?? 0);
+	const stepOutput = Number(normalizedUsage.outputTokens ?? 0);
+	const stepCached = Number(normalizedUsage.cachedInputTokens ?? 0);
+	const stepCacheCreation = Number(
+		normalizedUsage.cacheCreationInputTokens ?? 0,
+	);
+	const stepReasoning = Number(normalizedUsage.reasoningTokens ?? 0);
+
+	const sessRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, opts.sessionId));
+
+	if (sessRows.length === 0 || !sessRows[0]) return;
+
+	const sess = sessRows[0];
+
+	await db
+		.update(sessions)
+		.set({
+			totalInputTokens: Number(sess.totalInputTokens ?? 0) + stepInput,
+			totalOutputTokens: Number(sess.totalOutputTokens ?? 0) + stepOutput,
+			totalCachedTokens: Number(sess.totalCachedTokens ?? 0) + stepCached,
+			totalCacheCreationTokens:
+				Number(sess.totalCacheCreationTokens ?? 0) + stepCacheCreation,
+			totalReasoningTokens:
+				Number(sess.totalReasoningTokens ?? 0) + stepReasoning,
+			currentContextTokens,
+		})
+		.where(eq(sessions.id, opts.sessionId));
+}
+
+/**
+ * Updates session token counts after a run completes.
+ * @deprecated Use updateSessionTokensIncremental for per-step tracking
+ */
+export async function updateSessionTokens(
+	fin: { usage?: { inputTokens?: number; outputTokens?: number } },
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	if (!fin.usage || !db) return;
+
+	const sessRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, opts.sessionId));
+
+	if (sessRows.length > 0 && sessRows[0]) {
+		const row = sessRows[0];
+		const priorInput = Number(row.totalInputTokens ?? 0);
+		const priorOutput = Number(row.totalOutputTokens ?? 0);
+		const nextInput = priorInput + Number(fin.usage.inputTokens ?? 0);
+		const nextOutput = priorOutput + Number(fin.usage.outputTokens ?? 0);
+
+		await db
+			.update(sessions)
+			.set({
+				totalInputTokens: nextInput,
+				totalOutputTokens: nextOutput,
+			})
+			.where(eq(sessions.id, opts.sessionId));
+	}
+}
+
+/**
+ * Updates message token counts after each step.
+ * AI SDK v6: onStepFinish.usage is PER-STEP. We ADD each step's tokens to message totals.
+ */
+export async function updateMessageTokensIncremental(
+	usage: UsageData,
+	providerOptions: ProviderMetadata | undefined,
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	if (!usage || !db) return;
+
+	const usageProvider = resolveUsageProvider(opts.provider, opts.model);
+	const normalizedUsage = normalizeUsage(usage, providerOptions, usageProvider);
+
+	const stepInput = Number(normalizedUsage.inputTokens ?? 0);
+	const stepOutput = Number(normalizedUsage.outputTokens ?? 0);
+	const stepCached = Number(normalizedUsage.cachedInputTokens ?? 0);
+	const stepCacheCreation = Number(
+		normalizedUsage.cacheCreationInputTokens ?? 0,
+	);
+	const stepReasoning = Number(normalizedUsage.reasoningTokens ?? 0);
+
+	const msgRows = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.id, opts.assistantMessageId));
+
+	if (msgRows.length > 0 && msgRows[0]) {
+		const msg = msgRows[0];
+		const nextInput = Number(msg.inputTokens ?? 0) + stepInput;
+		const nextOutput = Number(msg.outputTokens ?? 0) + stepOutput;
+		const nextCached = Number(msg.cachedInputTokens ?? 0) + stepCached;
+		const nextCacheCreation =
+			Number(msg.cacheCreationInputTokens ?? 0) + stepCacheCreation;
+		const nextReasoning = Number(msg.reasoningTokens ?? 0) + stepReasoning;
+
+		await db
+			.update(messages)
+			.set({
+				inputTokens: nextInput,
+				outputTokens: nextOutput,
+				totalTokens:
+					nextInput +
+					nextOutput +
+					nextCached +
+					nextCacheCreation +
+					nextReasoning,
+				cachedInputTokens: nextCached,
+				cacheCreationInputTokens: nextCacheCreation,
+				reasoningTokens: nextReasoning,
+			})
+			.where(eq(messages.id, opts.assistantMessageId));
+	}
+}
+
+/**
+ * Marks an assistant message as complete.
+ * Token usage is tracked incrementally via updateMessageTokensIncremental().
+ */
+export async function completeAssistantMessage(
+	_fin: {
+		usage?: {
+			inputTokens?: number;
+			outputTokens?: number;
+			totalTokens?: number;
+		};
+	},
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	if (!db) return;
+
+	// Only mark as complete - tokens are already tracked incrementally
+	await db
+		.update(messages)
+		.set({
+			status: 'complete',
+			completedAt: Date.now(),
+		})
+		.where(eq(messages.id, opts.assistantMessageId));
+}
+
+/**
+ * Removes empty text parts from an assistant message.
+ */
+export async function cleanupEmptyTextParts(
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	if (!db) return;
+
+	const parts = await db
+		.select()
+		.from(messageParts)
+		.where(eq(messageParts.messageId, opts.assistantMessageId));
+
+	for (const p of parts) {
+		if (p.type === 'text') {
+			let t = '';
+			try {
+				t = JSON.parse(p.content || '{}')?.text || '';
+			} catch {}
+			if (!t || !t.trim()) {
+				await db.delete(messageParts).where(eq(messageParts.id, p.id));
+			}
+		}
+	}
+}