@ottocode/server 0.1.215 → 0.1.217

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.215",
+	"version": "0.1.217",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.215",
-		"@ottocode/database": "0.1.215",
+		"@ottocode/sdk": "0.1.217",
+		"@ottocode/database": "0.1.217",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.3.6"

package/src/openapi/paths/config.ts

@@ -178,6 +178,7 @@ export const configPaths = {
 								agent: { type: 'string' },
 								provider: { type: 'string' },
 								model: { type: 'string' },
+								reasoningText: { type: 'boolean' },
 								scope: {
 									type: 'string',
 									enum: ['global', 'local'],
@@ -203,6 +204,7 @@ export const configPaths = {
 											agent: { type: 'string' },
 											provider: { type: 'string' },
 											model: { type: 'string' },
+											reasoningText: { type: 'boolean' },
 										},
 										required: ['agent', 'provider', 'model'],
 									},

package/src/openapi/paths/messages.ts

@@ -67,6 +67,11 @@ export const messagesPaths = {
 									description:
 										'Optional user-provided context to include in the system prompt.',
 								},
+								reasoningText: {
+									type: 'boolean',
+									description:
+										'Enable extended thinking / reasoning for models that support it.',
+								},
 							},
 						},
 					},

package/src/openapi/paths/sessions.ts

@@ -6,15 +6,37 @@ export const sessionsPaths = {
 			tags: ['sessions'],
 			operationId: 'listSessions',
 			summary: 'List sessions',
-			parameters: [projectQueryParam()],
+			parameters: [
+				projectQueryParam(),
+				{
+					in: 'query',
+					name: 'limit',
+					schema: { type: 'integer', default: 50, minimum: 1, maximum: 200 },
+					description: 'Maximum number of sessions to return',
+				},
+				{
+					in: 'query',
+					name: 'offset',
+					schema: { type: 'integer', default: 0, minimum: 0 },
+					description: 'Offset for pagination',
+				},
+			],
 			responses: {
 				200: {
 					description: 'OK',
 					content: {
 						'application/json': {
 							schema: {
-								type: 'array',
-								items: { $ref: '#/components/schemas/Session' },
+								type: 'object',
+								properties: {
+									items: {
+										type: 'array',
+										items: { $ref: '#/components/schemas/Session' },
+									},
+									hasMore: { type: 'boolean' },
+									nextOffset: { type: 'integer', nullable: true },
+								},
+								required: ['items', 'hasMore', 'nextOffset'],
 							},
 						},
 					},
@@ -55,6 +77,79 @@ export const sessionsPaths = {
 			},
 		},
 	},
+	'/v1/sessions/{sessionId}': {
+		patch: {
+			tags: ['sessions'],
+			operationId: 'updateSession',
+			summary: 'Update session preferences',
+			parameters: [
+				{
+					in: 'path',
+					name: 'sessionId',
+					required: true,
+					schema: { type: 'string' },
+				},
+				projectQueryParam(),
+			],
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								title: { type: 'string' },
+								agent: { type: 'string' },
+								provider: { $ref: '#/components/schemas/Provider' },
+								model: { type: 'string' },
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: { $ref: '#/components/schemas/Session' },
+						},
+					},
+				},
+				400: errorResponse(),
+				404: errorResponse(),
+			},
+		},
+		delete: {
+			tags: ['sessions'],
+			operationId: 'deleteSession',
+			summary: 'Delete a session',
+			parameters: [
+				{
+					in: 'path',
+					name: 'sessionId',
+					required: true,
+					schema: { type: 'string' },
+				},
+				projectQueryParam(),
+			],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: { success: { type: 'boolean' } },
+								required: ['success'],
+							},
+						},
+					},
+				},
+				404: errorResponse(),
+			},
+		},
+	},
 	'/v1/sessions/{sessionId}/abort': {
 		delete: {
 			tags: ['sessions'],

package/src/openapi/paths/setu.ts

@@ -5,7 +5,7 @@ export const setuPaths = {
 			operationId: 'getSetuBalance',
 			summary: 'Get Setu account balance',
 			description:
-				'Returns wallet balance, total spent, total topups, and request count',
+				'Returns wallet balance, subscription, account info, limits, and usage data',
 			responses: {
 				200: {
 					description: 'OK',
@@ -19,6 +19,44 @@ export const setuPaths = {
 									totalSpent: { type: 'number' },
 									totalTopups: { type: 'number' },
 									requestCount: { type: 'number' },
+									scope: { type: 'string', enum: ['wallet', 'account'] },
+									payg: {
+										type: 'object',
+										properties: {
+											walletBalanceUsd: { type: 'number' },
+											accountBalanceUsd: { type: 'number' },
+											rawPoolUsd: { type: 'number' },
+											effectiveSpendableUsd: { type: 'number' },
+										},
+									},
+									limits: {
+										type: 'object',
+										nullable: true,
+										properties: {
+											enabled: { type: 'boolean' },
+											dailyLimitUsd: { type: 'number', nullable: true },
+											dailySpentUsd: { type: 'number' },
+											dailyRemainingUsd: { type: 'number', nullable: true },
+											monthlyLimitUsd: { type: 'number', nullable: true },
+											monthlySpentUsd: { type: 'number' },
+											monthlyRemainingUsd: { type: 'number', nullable: true },
+											capRemainingUsd: { type: 'number', nullable: true },
+										},
+									},
+									subscription: {
+										type: 'object',
+										nullable: true,
+										properties: {
+											active: { type: 'boolean' },
+											tierId: { type: 'string' },
+											tierName: { type: 'string' },
+											creditsIncluded: { type: 'number' },
+											creditsUsed: { type: 'number' },
+											creditsRemaining: { type: 'number' },
+											periodStart: { type: 'string' },
+											periodEnd: { type: 'string' },
+										},
+									},
 								},
 								required: [
 									'walletAddress',

package/src/openapi/paths/skills.ts

@@ -93,6 +93,90 @@ export const skillsPaths = {
 			},
 		},
 	},
+	'/v1/skills/{name}/files': {
+		get: {
+			tags: ['config'],
+			operationId: 'listSkillFiles',
+			summary: 'List files in a skill directory',
+			parameters: [
+				{
+					in: 'path',
+					name: 'name',
+					required: true,
+					schema: { type: 'string' },
+				},
+				projectQueryParam(),
+			],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									files: {
+										type: 'array',
+										items: {
+											type: 'object',
+											properties: {
+												relativePath: { type: 'string' },
+												size: { type: 'number' },
+											},
+											required: ['relativePath', 'size'],
+										},
+									},
+								},
+								required: ['files'],
+							},
+						},
+					},
+				},
+				500: errorResponse(),
+			},
+		},
+	},
+	'/v1/skills/{name}/files/{filePath}': {
+		get: {
+			tags: ['config'],
+			operationId: 'getSkillFile',
+			summary: 'Read a specific file from a skill directory',
+			parameters: [
+				{
+					in: 'path',
+					name: 'name',
+					required: true,
+					schema: { type: 'string' },
+				},
+				{
+					in: 'path',
+					name: 'filePath',
+					required: true,
+					schema: { type: 'string' },
+				},
+				projectQueryParam(),
+			],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									content: { type: 'string' },
+									path: { type: 'string' },
+								},
+								required: ['content', 'path'],
+							},
+						},
+					},
+				},
+				404: errorResponse(),
+				500: errorResponse(),
+			},
+		},
+	},
 	'/v1/skills/validate': {
 		post: {
 			tags: ['config'],

package/src/openapi/schemas.ts

@@ -194,6 +194,7 @@ export const schemas = {
 					agent: { type: 'string' },
 					provider: { $ref: '#/components/schemas/Provider' },
 					model: { type: 'string' },
+					reasoningText: { type: 'boolean' },
 				},
 				required: ['agent', 'provider', 'model'],
 			},

package/src/routes/config/defaults.ts

@@ -13,6 +13,8 @@ export function registerDefaultsRoute(app: Hono) {
 				model?: string;
 				toolApproval?: 'auto' | 'dangerous' | 'all';
 				guidedMode?: boolean;
+				reasoningText?: boolean;
+				theme?: string;
 				scope?: 'global' | 'local';
 			}>();
 
@@ -23,6 +25,8 @@ export function registerDefaultsRoute(app: Hono) {
 				model: string;
 				toolApproval: 'auto' | 'dangerous' | 'all';
 				guidedMode: boolean;
+				reasoningText: boolean;
+				theme: string;
 			}> = {};
 
 			if (body.agent) updates.agent = body.agent;
@@ -30,6 +34,9 @@ export function registerDefaultsRoute(app: Hono) {
 			if (body.model) updates.model = body.model;
 			if (body.toolApproval) updates.toolApproval = body.toolApproval;
 			if (body.guidedMode !== undefined) updates.guidedMode = body.guidedMode;
+			if (body.reasoningText !== undefined)
+				updates.reasoningText = body.reasoningText;
+			if (body.theme) updates.theme = body.theme;
 
 			await setConfig(scope, updates, projectRoot);
 

package/src/routes/config/main.ts

@@ -58,6 +58,8 @@ export function registerMainConfigRoute(app: Hono) {
 					cfg.defaults.toolApproval,
 				) as 'auto' | 'dangerous' | 'all',
 				guidedMode: cfg.defaults.guidedMode ?? false,
+				reasoningText: cfg.defaults.reasoningText ?? true,
+				theme: cfg.defaults.theme,
 			};
 
 			return c.json({

package/src/routes/session-messages.ts

@@ -122,7 +122,8 @@ export function registerSessionMessagesRoutes(app: Hono) {
 				typeOf: typeof userContext,
 			});
 
-			const reasoning = body?.reasoningText === true;
+			const reasoning =
+				body?.reasoningText ?? cfg.defaults.reasoningText ?? false;
 
 			// Validate model capabilities if tools are allowed for this agent
 			const wantsToolCalls = true; // agent toolset may be non-empty

package/src/routes/sessions.ts

@@ -140,11 +140,16 @@ export function registerSessionsRoutes(app: Hono) {
 				agent?: string;
 				provider?: string;
 				model?: string;
+				title?: string | null;
 				lastActiveAt?: number;
 			} = {
 				lastActiveAt: Date.now(),
 			};
 
+			if (typeof body.title === 'string') {
+				updates.title = body.title.trim() || null;
+			}
+
 			// Validate agent if provided
 			if (typeof body.agent === 'string') {
 				const agentName = body.agent.trim();

package/src/routes/skills.ts

@@ -2,6 +2,8 @@ import type { Hono } from 'hono';
 import {
 	discoverSkills,
 	loadSkill,
+	loadSkillFile,
+	discoverSkillFiles,
 	findGitRoot,
 	validateSkillName,
 	parseSkillFile,
@@ -61,6 +63,51 @@ export function registerSkillsRoutes(app: Hono) {
 	});
 
 	app.post('/v1/skills/validate', async (c) => {
+		app.get('/v1/skills/:name/files', async (c) => {
+			try {
+				const name = c.req.param('name');
+				const projectRoot = c.req.query('project') || process.cwd();
+				const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+				await discoverSkills(projectRoot, repoRoot);
+
+				const files = await discoverSkillFiles(name);
+				return c.json({ files });
+			} catch (error) {
+				logger.error('Failed to list skill files', error);
+				const errorResponse = serializeError(error);
+				return c.json(
+					errorResponse,
+					(errorResponse.error.status || 500) as 500,
+				);
+			}
+		});
+
+		app.get('/v1/skills/:name/files/*', async (c) => {
+			try {
+				const name = c.req.param('name');
+				const filePath = c.req.path.replace(`/v1/skills/${name}/files/`, '');
+				const projectRoot = c.req.query('project') || process.cwd();
+				const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+				await discoverSkills(projectRoot, repoRoot);
+
+				const result = await loadSkillFile(name, filePath);
+				if (!result) {
+					return c.json(
+						{ error: `File '${filePath}' not found in skill '${name}'` },
+						404,
+					);
+				}
+				return c.json({ content: result.content, path: result.resolvedPath });
+			} catch (error) {
+				logger.error('Failed to load skill file', error);
+				const errorResponse = serializeError(error);
+				return c.json(
+					errorResponse,
+					(errorResponse.error.status || 500) as 500,
+				);
+			}
+		});
+
 		try {
 			const body = await c.req.json<{ content: string; path?: string }>();
 			if (!body.content) {

package/src/runtime/message/history-builder.ts

@@ -12,7 +12,7 @@ import { ToolHistoryTracker } from './tool-history-tracker.ts';
 export async function buildHistoryMessages(
 	db: Awaited<ReturnType<typeof getDb>>,
 	sessionId: string,
-	currentMessageId?: string,
+	_currentMessageId?: string,
 ): Promise<ModelMessage[]> {
 	const rows = await db
 		.select()
@@ -24,26 +24,30 @@ export async function buildHistoryMessages(
 	const toolHistory = new ToolHistoryTracker();
 
 	for (const m of rows) {
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, m.id))
+			.orderBy(asc(messageParts.index));
+
 		if (
 			m.role === 'assistant' &&
 			m.status !== 'complete' &&
 			m.status !== 'completed' &&
-			m.status !== 'error' &&
-			m.id !== currentMessageId
+			m.status !== 'error'
 		) {
+			if (parts.length === 0) {
+				debugLog(
+					`[buildHistoryMessages] Skipping empty assistant message ${m.id} with status ${m.status}`,
+				);
+				continue;
+			}
+
 			debugLog(
-				`[buildHistoryMessages] Skipping assistant message ${m.id} with status ${m.status}`,
+				`[buildHistoryMessages] Including non-complete assistant message ${m.id} (status: ${m.status}) with ${parts.length} parts to preserve context`,
 			);
-			logPendingToolParts(db, m.id);
-			continue;
 		}
 
-		const parts = await db
-			.select()
-			.from(messageParts)
-			.where(eq(messageParts.messageId, m.id))
-			.orderBy(asc(messageParts.index));
-
 		if (m.role === 'user') {
 			const uparts: UIMessage['parts'] = [];
 			for (const p of parts) {
@@ -123,7 +127,6 @@ export async function buildHistoryMessages(
 						if (t) assistantParts.push({ type: 'text', text: t });
 					} catch {}
 				} else if (p.type === 'tool_call') {
-					// Skip compacted tool calls entirely
 					if (p.compactedAt) continue;
 
 					try {
@@ -141,7 +144,6 @@ export async function buildHistoryMessages(
 						}
 					} catch {}
 				} else if (p.type === 'tool_result') {
-					// Skip compacted tool results entirely
 					if (p.compactedAt) continue;
 
 					try {
@@ -159,7 +161,6 @@ export async function buildHistoryMessages(
 						}
 					} catch {}
 				}
-				// Skip error parts in history
 			}
 
 			const toolResultsById = new Map(
@@ -167,14 +168,12 @@ export async function buildHistoryMessages(
 			);
 
 			for (const call of toolCalls) {
-				// Skip finish tool from history - it's internal loop control
 				if (call.name === 'finish') continue;
 
 				const toolType = `tool-${call.name}` as `tool-${string}`;
 				let result = toolResultsById.get(call.callId);
 
 				if (!result) {
-					// Synthesize a result for incomplete tool calls to preserve history
 					debugLog(
 						`[buildHistoryMessages] Synthesizing error result for incomplete tool call ${call.name}#${call.callId}`,
 					);
@@ -221,7 +220,7 @@ export async function buildHistoryMessages(
 	return await convertToModelMessages(ui);
 }
 
-async function logPendingToolParts(
+async function _logPendingToolParts(
 	db: Awaited<ReturnType<typeof getDb>>,
 	messageId: string,
 ) {

package/src/runtime/tools/mapping.ts

@@ -99,7 +99,7 @@ export function toClaudeCodeName(canonical: string): string {
 	}
 	// Default: convert snake_case to PascalCase
 	return canonical
-		.split('_')
+		.split(/[\s_]+/)
 		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
 		.join('');
 }