@ottocode/server 0.1.192 → 0.1.194

package/package.json

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

package/src/index.ts

@@ -20,6 +20,7 @@ import { registerSessionApprovalRoute } from './routes/session-approval.ts';
 import { registerSetuRoutes } from './routes/setu.ts';
 import { registerAuthRoutes } from './routes/auth.ts';
 import { registerTunnelRoutes } from './routes/tunnel.ts';
+import { registerProviderUsageRoutes } from './routes/provider-usage.ts';
 import type { AgentConfigEntry } from './runtime/agent/registry.ts';
 
 const globalTerminalManager = new TerminalManager();
@@ -76,6 +77,7 @@ function initApp() {
 	registerSetuRoutes(app);
 	registerAuthRoutes(app);
 	registerTunnelRoutes(app);
+	registerProviderUsageRoutes(app);
 
 	return app;
 }
@@ -148,6 +150,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
 	registerTunnelRoutes(honoApp);
+	registerProviderUsageRoutes(honoApp);
 
 	return honoApp;
 }
@@ -248,6 +251,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
 	registerTunnelRoutes(honoApp);
+	registerProviderUsageRoutes(honoApp);
 
 	return honoApp;
 }

package/src/openapi/paths/git.ts

@@ -350,6 +350,52 @@ export const gitPaths = {
 			},
 		},
 	},
+	'/v1/git/pull': {
+		post: {
+			tags: ['git'],
+			operationId: 'pullChanges',
+			summary: 'Pull changes from remote',
+			description: 'Pulls changes from the configured remote repository',
+			requestBody: {
+				required: false,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											output: { type: 'string' },
+										},
+										required: ['output'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				400: gitErrorResponse(),
+				500: gitErrorResponse(),
+			},
+		},
+	},
 	'/v1/git/restore': {
 		post: {
 			tags: ['git'],

package/src/routes/auth.ts

@@ -161,6 +161,27 @@ export function registerAuthRoutes(app: Hono) {
 		}
 	});
 
+	app.get('/v1/auth/setu/export', async (c) => {
+		try {
+			const projectRoot = process.cwd();
+			const wallet = await getSetuWallet(projectRoot);
+
+			if (!wallet) {
+				return c.json({ error: 'Setu wallet not configured' }, 404);
+			}
+
+			return c.json({
+				success: true,
+				publicKey: wallet.publicKey,
+				privateKey: wallet.privateKey,
+			});
+		} catch (error) {
+			logger.error('Failed to export Setu wallet', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
 	app.post('/v1/auth/:provider', async (c) => {
 		try {
 			const provider = c.req.param('provider') as ProviderId;

package/src/routes/git/index.ts

@@ -5,6 +5,7 @@ import { registerDiffRoute } from './diff.ts';
 import { registerStagingRoutes } from './staging.ts';
 import { registerCommitRoutes } from './commit.ts';
 import { registerPushRoute } from './push.ts';
+import { registerPullRoute } from './pull.ts';
 
 export type { GitFile } from './types.ts';
 
@@ -15,4 +16,5 @@ export function registerGitRoutes(app: Hono) {
 	registerStagingRoutes(app);
 	registerCommitRoutes(app);
 	registerPushRoute(app);
+	registerPullRoute(app);
 }

package/src/routes/git/pull.ts

@@ -0,0 +1,98 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitPullSchema } from './schemas.ts';
+import { validateAndGetGitRoot } from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerPullRoute(app: Hono) {
+	app.post('/v1/git/pull', async (c) => {
+		try {
+			let body = {};
+			try {
+				body = await c.req.json();
+			} catch {
+				body = {};
+			}
+
+			const { project } = gitPullSchema.parse(body);
+
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			try {
+				const result = await execFileAsync('git', ['pull'], {
+					cwd: gitRoot,
+				});
+
+				return c.json({
+					status: 'ok',
+					data: {
+						output: result.stdout.trim() || result.stderr.trim(),
+					},
+				});
+			} catch (pullErr: unknown) {
+				const error = pullErr as {
+					message?: string;
+					stderr?: string;
+				};
+				const errorMessage = error.stderr || error.message || 'Failed to pull';
+
+				if (
+					errorMessage.includes('CONFLICT') ||
+					errorMessage.includes('merge conflict')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Merge conflicts detected. Resolve conflicts manually',
+							details: errorMessage,
+						},
+						400,
+					);
+				}
+
+				if (
+					errorMessage.includes('Permission denied') ||
+					errorMessage.includes('authentication')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Authentication failed. Check your git credentials',
+							details: errorMessage,
+						},
+						401,
+					);
+				}
+
+				return c.json(
+					{
+						status: 'error',
+						error: 'Failed to pull changes',
+						details: errorMessage,
+					},
+					500,
+				);
+			}
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error: error instanceof Error ? error.message : 'Failed to pull',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/schemas.ts

@@ -46,3 +46,7 @@ export const gitGenerateCommitMessageSchema = z.object({
 export const gitPushSchema = z.object({
 	project: z.string().optional(),
 });
+
+export const gitPullSchema = z.object({
+	project: z.string().optional(),
+});

package/src/routes/provider-usage.ts

@@ -0,0 +1,199 @@
+import type { Hono } from 'hono';
+import {
+	getAuth,
+	refreshToken,
+	refreshOpenAIToken,
+	type ProviderId,
+} from '@ottocode/sdk';
+import { logger } from '@ottocode/sdk';
+import { setAuth } from '@ottocode/sdk';
+import { serializeError } from '../runtime/errors/api-error.ts';
+import type { OAuth } from '@ottocode/sdk';
+
+async function ensureValidOAuth(
+	provider: ProviderId,
+): Promise<{ access: string; oauth: OAuth } | null> {
+	const projectRoot = process.cwd();
+	const auth = await getAuth(provider, projectRoot);
+	if (!auth || auth.type !== 'oauth') return null;
+
+	if (auth.access && auth.expires > Date.now()) {
+		return { access: auth.access, oauth: auth };
+	}
+
+	try {
+		const refreshFn = provider === 'openai' ? refreshOpenAIToken : refreshToken;
+		const newTokens = await refreshFn(auth.refresh);
+		const updated: OAuth = {
+			...auth,
+			access: newTokens.access,
+			refresh: newTokens.refresh,
+			expires: newTokens.expires,
+		};
+		await setAuth(provider, updated, projectRoot, 'global');
+		return { access: updated.access, oauth: updated };
+	} catch {
+		return { access: auth.access, oauth: auth };
+	}
+}
+
+async function fetchAnthropicUsage(access: string) {
+	const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+		headers: {
+			Authorization: `Bearer ${access}`,
+			'anthropic-beta': 'oauth-2025-04-20',
+			Accept: 'application/json',
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error(`Anthropic usage API returned ${response.status}`);
+	}
+
+	const data = (await response.json()) as {
+		five_hour?: { utilization: number; resets_at: string | null };
+		seven_day?: { utilization: number; resets_at: string | null };
+		seven_day_sonnet?: { utilization: number; resets_at: string | null };
+		extra_usage?: {
+			is_enabled: boolean;
+			monthly_limit: number;
+			used_credits: number;
+			utilization: number | null;
+		};
+	};
+
+	return {
+		provider: 'anthropic' as const,
+		primaryWindow: data.five_hour
+			? {
+					usedPercent: data.five_hour.utilization,
+					windowSeconds: 18000,
+					resetsAt: data.five_hour.resets_at,
+				}
+			: null,
+		secondaryWindow: data.seven_day
+			? {
+					usedPercent: data.seven_day.utilization,
+					windowSeconds: 604800,
+					resetsAt: data.seven_day.resets_at,
+				}
+			: null,
+		sonnetWindow: data.seven_day_sonnet
+			? {
+					usedPercent: data.seven_day_sonnet.utilization,
+					resetsAt: data.seven_day_sonnet.resets_at,
+				}
+			: null,
+		extraUsage: data.extra_usage ?? null,
+		limitReached: (data.five_hour?.utilization ?? 0) >= 100,
+		raw: data,
+	};
+}
+
+async function fetchOpenAIUsage(access: string, accountId?: string) {
+	const headers: Record<string, string> = {
+		Authorization: `Bearer ${access}`,
+		Accept: '*/*',
+	};
+	if (accountId) {
+		headers['ChatGPT-Account-Id'] = accountId;
+	}
+	const response = await fetch('https://chatgpt.com/backend-api/wham/usage', {
+		headers,
+	});
+
+	if (!response.ok) {
+		throw new Error(`OpenAI usage API returned ${response.status}`);
+	}
+
+	const data = (await response.json()) as {
+		plan_type?: string;
+		rate_limit?: {
+			allowed: boolean;
+			limit_reached: boolean;
+			primary_window?: {
+				used_percent: number;
+				limit_window_seconds: number;
+				reset_after_seconds: number;
+				reset_at: number;
+			};
+			secondary_window?: {
+				used_percent: number;
+				limit_window_seconds: number;
+				reset_after_seconds: number;
+				reset_at: number;
+			} | null;
+		};
+		credits?: {
+			has_credits: boolean;
+			balance: number | null;
+		};
+	};
+
+	const rl = data.rate_limit;
+	return {
+		provider: 'openai' as const,
+		planType: data.plan_type ?? null,
+		primaryWindow: rl?.primary_window
+			? {
+					usedPercent: rl.primary_window.used_percent,
+					windowSeconds: rl.primary_window.limit_window_seconds,
+					resetsAt: new Date(rl.primary_window.reset_at * 1000).toISOString(),
+					resetAfterSeconds: rl.primary_window.reset_after_seconds,
+				}
+			: null,
+		secondaryWindow: rl?.secondary_window
+			? {
+					usedPercent: rl.secondary_window.used_percent,
+					windowSeconds: rl.secondary_window.limit_window_seconds,
+					resetsAt: new Date(rl.secondary_window.reset_at * 1000).toISOString(),
+					resetAfterSeconds: rl.secondary_window.reset_after_seconds,
+				}
+			: null,
+		credits: data.credits ?? null,
+		limitReached: rl?.limit_reached ?? false,
+		raw: data,
+	};
+}
+
+export function registerProviderUsageRoutes(app: Hono) {
+	app.get('/v1/provider-usage/:provider', async (c) => {
+		try {
+			const provider = c.req.param('provider') as ProviderId;
+
+			if (provider !== 'anthropic' && provider !== 'openai') {
+				return c.json(
+					{ error: { message: 'Usage not supported for this provider' } },
+					400,
+				);
+			}
+
+			const tokenResult = await ensureValidOAuth(provider);
+			if (!tokenResult) {
+				return c.json(
+					{
+						error: {
+							message: `No OAuth credentials for ${provider}. Usage is only available for OAuth-authenticated providers.`,
+						},
+					},
+					404,
+				);
+			}
+
+			const usage =
+				provider === 'anthropic'
+					? await fetchAnthropicUsage(tokenResult.access)
+					: await fetchOpenAIUsage(
+							tokenResult.access,
+							tokenResult.oauth.accountId,
+						);
+
+			return c.json(usage);
+		} catch (error) {
+			logger.error('Failed to fetch provider usage', error);
+			const errorResponse = serializeError(error);
+			const status = (errorResponse.error.status || 500) as 500;
+			return c.json(errorResponse, status);
+		}
+	});
+}

package/src/runtime/agent/runner.ts

@@ -1,11 +1,12 @@
 import { hasToolCall, streamText } from 'ai';
-import { messageParts } from '@ottocode/database/schema';
+import { messages, messageParts } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
 import { publish, subscribe } from '../../events/bus.ts';
 import { debugLog, time } from '../debug/index.ts';
 import { toErrorPayload } from '../errors/handling.ts';
 import {
 	type RunOpts,
+	enqueueAssistantRun,
 	setRunning,
 	dequeueJob,
 	cleanupSession,
@@ -293,13 +294,75 @@ async function runAssistant(opts: RunOpts) {
 		await cleanupEmptyTextParts(opts, db);
 		firstToolTimer.end({ seen: firstToolSeen() });
 
+		let streamFinishReason: string | undefined;
+		try {
+			streamFinishReason = await result.finishReason;
+		} catch {
+			streamFinishReason = undefined;
+		}
+
 		debugLog(
-			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}`,
+			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}, finishReason=${streamFinishReason}`,
 		);
 
-		if (!_finishObserved && fs) {
+		const wasTruncated = streamFinishReason === 'length';
+
+		const shouldContinue =
+			opts.provider === 'openai' &&
+			isOpenAIOAuth &&
+			!_finishObserved &&
+			(wasTruncated || fs);
+
+		if (shouldContinue) {
+			debugLog(
+				`[RUNNER] WARNING: Stream ended without finish. finishReason=${streamFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
+			);
+
+			const MAX_CONTINUATIONS = 10;
+			const count = opts.continuationCount ?? 0;
+			if (count < MAX_CONTINUATIONS) {
+				debugLog(
+					`[RUNNER] Auto-continuing (${count + 1}/${MAX_CONTINUATIONS})...`,
+				);
+
+				try {
+					await completeAssistantMessage({}, opts, db);
+				} catch (err) {
+					debugLog(
+						`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+
+				const continuationMessageId = crypto.randomUUID();
+				await db.insert(messages).values({
+					id: continuationMessageId,
+					sessionId: opts.sessionId,
+					role: 'assistant',
+					status: 'pending',
+					agent: opts.agent,
+					provider: opts.provider,
+					model: opts.model,
+					createdAt: Date.now(),
+				});
+
+				publish({
+					type: 'message.created',
+					sessionId: opts.sessionId,
+					payload: { id: continuationMessageId, role: 'assistant' },
+				});
+
+				enqueueAssistantRun(
+					{
+						...opts,
+						assistantMessageId: continuationMessageId,
+						continuationCount: count + 1,
+					},
+					runSessionLoop,
+				);
+				return;
+			}
 			debugLog(
-				`[RUNNER] WARNING: Stream ended without finish tool being called. Model was mid-execution (tools were used). This is likely an unclean stream termination from the provider.`,
+				`[RUNNER] Max continuations (${MAX_CONTINUATIONS}) reached, stopping.`,
 			);
 		}
 	} catch (err) {

package/src/runtime/session/queue.ts

@@ -17,6 +17,7 @@ export type RunOpts = {
 	compactionContext?: string;
 	toolApprovalMode?: ToolApprovalMode;
 	compactionRetries?: number;
+	continuationCount?: number;
 };
 
 export type QueuedMessage = {