@agentuity/core 2.0.10 → 2.0.12

package/src/services/coder/sessions.ts

@@ -1,15 +1,18 @@
 import { z } from 'zod/v4';
 import { type APIClient } from '../api.ts';
 import {
+	CoderCreateAgentBuilderSessionRequestSchema,
 	CoderCreateSessionRequestSchema,
 	CoderListSessionsParamsSchema,
 	CoderSessionListResponseSchema,
 	CoderSessionListItemSchema,
 	CoderSessionSchema,
 	CoderUpdateSessionRequestSchema,
+	type CoderCreateAgentBuilderSessionRequest,
 	type CoderCreateSessionRequest,
 	type CoderListSessionsParams,
 	type CoderSession,
+	type CoderSessionListItem,
 	type CoderSessionListResponse,
 	type CoderUpdateSessionRequest,
 } from './types.ts';
@@ -22,7 +25,7 @@ const CoderHubSessionListResponseSchema = z.object({
 	total: z.number(),
 });
 
-const CoderLifecycleResponseSchema = z
+export const CoderLifecycleResponseSchema = z
 	.object({
 		sessionId: z.string().describe('Session identifier'),
 		status: z.string().optional().describe('New session status'),
@@ -45,6 +48,18 @@ export const CoderCreateSessionParamsSchema = z
 	.describe('Parameters for creating a coder session');
 export type CoderCreateSessionParams = z.infer<typeof CoderCreateSessionParamsSchema>;
 
+export const CoderCreateAgentBuilderSessionParamsSchema = z
+	.object({
+		body: CoderCreateAgentBuilderSessionRequestSchema.describe(
+			'Create-agent-builder-session request body'
+		),
+		orgId: z.string().optional().describe('Optional org id for CLI auth context'),
+	})
+	.describe('Parameters for creating an agent-builder session');
+export type CoderCreateAgentBuilderSessionParams = z.infer<
+	typeof CoderCreateAgentBuilderSessionParamsSchema
+>;
+
 export const CoderGetSessionParamsSchema = CoderSessionIdParamsSchema.describe(
 	'Parameters for retrieving a coder session'
 );
@@ -141,6 +156,18 @@ export async function coderCreateSession(
 	);
 }
 
+export async function coderCreateAgentBuilderSession(
+	client: APIClient,
+	params: CoderCreateAgentBuilderSessionParams
+): Promise<CoderCreateSessionResponse> {
+	return client.post<CoderCreateSessionResponse, CoderCreateAgentBuilderSessionRequest>(
+		'/hub/session/builder',
+		params.body,
+		CoderCreateSessionResponseSchema,
+		CoderCreateAgentBuilderSessionRequestSchema
+	);
+}
+
 export async function coderGetSession(
 	client: APIClient,
 	params: CoderGetSessionParams
@@ -212,6 +239,22 @@ export interface CoderLifecycleResponse {
 	status?: string;
 }
 
+function isConnectableSession(session: CoderSessionListItem): boolean {
+	if (session.mode !== 'sandbox' || session.historyOnly === true) {
+		return false;
+	}
+
+	if (session.bucket === 'running') {
+		return true;
+	}
+
+	if (session.bucket === 'paused') {
+		return session.runtimeAvailable === true || session.wakeAvailable === true;
+	}
+
+	return false;
+}
+
 export async function coderArchiveSession(
 	client: APIClient,
 	params: CoderSessionIdParams
@@ -220,18 +263,31 @@ export async function coderArchiveSession(
 	return client.post<CoderLifecycleResponse>(path, undefined, CoderLifecycleResponseSchema);
 }
 
+export async function coderResumeSession(
+	client: APIClient,
+	params: CoderSessionIdParams
+): Promise<CoderLifecycleResponse> {
+	const path = `/hub/session/${encodeURIComponent(params.sessionId)}/resume`;
+	return client.post<CoderLifecycleResponse>(path, undefined, CoderLifecycleResponseSchema);
+}
+
 export async function coderListConnectableSessions(
 	client: APIClient,
 	params?: CoderListConnectableSessionsParams
 ): Promise<CoderSessionListResponse> {
-	const path = `/hub/sessions/connectable${buildListQuery(params)}`;
-	const raw = await client.get<z.infer<typeof CoderHubSessionListResponseSchema>>(
-		path,
-		CoderHubSessionListResponseSchema
-	);
-
-	return normalizeSessionList({
-		sessions: raw.sessions.websocket,
-		total: raw.total,
+	const raw = await coderListSessions(client, {
+		search: params?.search,
+		includeArchived: true,
+		orgId: params?.orgId,
 	});
+	const connectable = raw.sessions.filter(isConnectableSession);
+	const normalizedOffset = Math.max(0, params?.offset ?? 0);
+	const normalizedLimit = Math.max(0, params?.limit ?? connectable.length);
+
+	return {
+		sessions: connectable.slice(normalizedOffset, normalizedOffset + normalizedLimit),
+		total: connectable.length,
+		...(params?.limit !== undefined ? { limit: normalizedLimit } : {}),
+		...(params?.offset !== undefined ? { offset: normalizedOffset } : {}),
+	};
 }