mirror of
https://github.com/getcompanion-ai/co-mono.git
synced 2026-04-15 06:04:40 +00:00
750 lines
22 KiB
TypeScript
750 lines
22 KiB
TypeScript
import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
|
|
import { join } from "node:path";
|
|
import { URL } from "node:url";
|
|
import type { ImageContent } from "@mariozechner/pi-ai";
|
|
import type { AgentSession, AgentSessionEvent } from "./agent-session.js";
|
|
import { SessionManager } from "./session-manager.js";
|
|
import {
|
|
createVercelStreamListener,
|
|
errorVercelStream,
|
|
extractUserText,
|
|
finishVercelStream,
|
|
} from "./vercel-ai-stream.js";
|
|
|
|
export interface GatewayConfig {
|
|
bind: string;
|
|
port: number;
|
|
bearerToken?: string;
|
|
session: {
|
|
idleMinutes: number;
|
|
maxQueuePerSession: number;
|
|
};
|
|
webhook: {
|
|
enabled: boolean;
|
|
basePath: string;
|
|
secret?: string;
|
|
};
|
|
}
|
|
|
|
export type GatewaySessionFactory = (sessionKey: string) => Promise<AgentSession>;
|
|
|
|
export interface GatewayMessageRequest {
|
|
sessionKey: string;
|
|
text: string;
|
|
source?: "interactive" | "rpc" | "extension";
|
|
images?: ImageContent[];
|
|
metadata?: Record<string, unknown>;
|
|
}
|
|
|
|
export interface GatewayMessageResult {
|
|
ok: boolean;
|
|
response: string;
|
|
error?: string;
|
|
sessionKey: string;
|
|
}
|
|
|
|
export interface GatewaySessionSnapshot {
|
|
sessionKey: string;
|
|
sessionId: string;
|
|
messageCount: number;
|
|
queueDepth: number;
|
|
processing: boolean;
|
|
lastActiveAt: number;
|
|
createdAt: number;
|
|
}
|
|
|
|
export interface GatewayRuntimeOptions {
|
|
config: GatewayConfig;
|
|
primarySessionKey: string;
|
|
primarySession: AgentSession;
|
|
createSession: GatewaySessionFactory;
|
|
log?: (message: string) => void;
|
|
}
|
|
|
|
interface GatewayQueuedMessage {
|
|
request: GatewayMessageRequest;
|
|
resolve: (result: GatewayMessageResult) => void;
|
|
onStart?: () => void;
|
|
onFinish?: () => void;
|
|
}
|
|
|
|
type GatewayEvent =
|
|
| { type: "hello"; sessionKey: string; snapshot: GatewaySessionSnapshot }
|
|
| { type: "session_state"; sessionKey: string; snapshot: GatewaySessionSnapshot }
|
|
| { type: "turn_start"; sessionKey: string }
|
|
| { type: "turn_end"; sessionKey: string }
|
|
| { type: "message_start"; sessionKey: string; role?: string }
|
|
| { type: "token"; sessionKey: string; delta: string; contentIndex: number }
|
|
| { type: "thinking"; sessionKey: string; delta: string; contentIndex: number }
|
|
| { type: "tool_start"; sessionKey: string; toolCallId: string; toolName: string; args: unknown }
|
|
| { type: "tool_update"; sessionKey: string; toolCallId: string; toolName: string; partialResult: unknown }
|
|
| {
|
|
type: "tool_complete";
|
|
sessionKey: string;
|
|
toolCallId: string;
|
|
toolName: string;
|
|
result: unknown;
|
|
isError: boolean;
|
|
}
|
|
| { type: "message_complete"; sessionKey: string; text: string }
|
|
| { type: "error"; sessionKey: string; error: string }
|
|
| { type: "aborted"; sessionKey: string };
|
|
|
|
interface ManagedGatewaySession {
|
|
sessionKey: string;
|
|
session: AgentSession;
|
|
queue: GatewayQueuedMessage[];
|
|
processing: boolean;
|
|
createdAt: number;
|
|
lastActiveAt: number;
|
|
listeners: Set<(event: GatewayEvent) => void>;
|
|
unsubscribe: () => void;
|
|
}
|
|
|
|
let activeGatewayRuntime: GatewayRuntime | null = null;
|
|
|
|
export function setActiveGatewayRuntime(runtime: GatewayRuntime | null): void {
|
|
activeGatewayRuntime = runtime;
|
|
}
|
|
|
|
export function getActiveGatewayRuntime(): GatewayRuntime | null {
|
|
return activeGatewayRuntime;
|
|
}
|
|
|
|
export class GatewayRuntime {
|
|
private readonly config: GatewayConfig;
|
|
private readonly primarySessionKey: string;
|
|
private readonly primarySession: AgentSession;
|
|
private readonly createSession: GatewaySessionFactory;
|
|
private readonly log: (message: string) => void;
|
|
private readonly sessions = new Map<string, ManagedGatewaySession>();
|
|
private readonly sessionDirRoot: string;
|
|
private server: Server | null = null;
|
|
private idleSweepTimer: NodeJS.Timeout | null = null;
|
|
private ready = false;
|
|
|
|
constructor(options: GatewayRuntimeOptions) {
|
|
this.config = options.config;
|
|
this.primarySessionKey = options.primarySessionKey;
|
|
this.primarySession = options.primarySession;
|
|
this.createSession = options.createSession;
|
|
this.log = options.log ?? (() => {});
|
|
this.sessionDirRoot = join(options.primarySession.sessionManager.getSessionDir(), "..", "gateway-sessions");
|
|
}
|
|
|
|
async start(): Promise<void> {
|
|
if (this.server) return;
|
|
|
|
await this.ensureSession(this.primarySessionKey, this.primarySession);
|
|
this.server = createServer((request, response) => {
|
|
void this.handleHttpRequest(request, response).catch((error) => {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
this.writeJson(response, 500, { error: message });
|
|
});
|
|
});
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
this.server?.once("error", reject);
|
|
this.server?.listen(this.config.port, this.config.bind, () => {
|
|
this.server?.off("error", reject);
|
|
resolve();
|
|
});
|
|
});
|
|
|
|
this.idleSweepTimer = setInterval(() => {
|
|
void this.evictIdleSessions();
|
|
}, 60_000);
|
|
this.ready = true;
|
|
}
|
|
|
|
async stop(): Promise<void> {
|
|
this.ready = false;
|
|
if (this.idleSweepTimer) {
|
|
clearInterval(this.idleSweepTimer);
|
|
this.idleSweepTimer = null;
|
|
}
|
|
if (this.server) {
|
|
await new Promise<void>((resolve, reject) => {
|
|
this.server?.close((error) => {
|
|
if (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
resolve();
|
|
});
|
|
});
|
|
this.server = null;
|
|
}
|
|
for (const [sessionKey, managedSession] of this.sessions) {
|
|
managedSession.unsubscribe();
|
|
if (sessionKey !== this.primarySessionKey) {
|
|
managedSession.session.dispose();
|
|
}
|
|
}
|
|
this.sessions.clear();
|
|
}
|
|
|
|
isReady(): boolean {
|
|
return this.ready;
|
|
}
|
|
|
|
getAddress(): { bind: string; port: number } {
|
|
return { bind: this.config.bind, port: this.config.port };
|
|
}
|
|
|
|
async enqueueMessage(request: GatewayMessageRequest): Promise<GatewayMessageResult> {
|
|
return this.enqueueManagedMessage({ request });
|
|
}
|
|
|
|
private async enqueueManagedMessage(queuedMessage: {
|
|
request: GatewayMessageRequest;
|
|
onStart?: () => void;
|
|
onFinish?: () => void;
|
|
}): Promise<GatewayMessageResult> {
|
|
const managedSession = await this.ensureSession(queuedMessage.request.sessionKey);
|
|
if (managedSession.queue.length >= this.config.session.maxQueuePerSession) {
|
|
return {
|
|
ok: false,
|
|
response: "",
|
|
error: `Queue full (${this.config.session.maxQueuePerSession} pending).`,
|
|
sessionKey: queuedMessage.request.sessionKey,
|
|
};
|
|
}
|
|
|
|
return new Promise<GatewayMessageResult>((resolve) => {
|
|
managedSession.queue.push({ ...queuedMessage, resolve });
|
|
this.emitState(managedSession);
|
|
void this.processNext(managedSession);
|
|
});
|
|
}
|
|
|
|
async addSubscriber(sessionKey: string, listener: (event: GatewayEvent) => void): Promise<() => void> {
|
|
const managedSession = await this.ensureSession(sessionKey);
|
|
managedSession.listeners.add(listener);
|
|
listener({ type: "hello", sessionKey, snapshot: this.createSnapshot(managedSession) });
|
|
return () => {
|
|
managedSession.listeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
abortSession(sessionKey: string): boolean {
|
|
const managedSession = this.sessions.get(sessionKey);
|
|
if (!managedSession?.processing) {
|
|
return false;
|
|
}
|
|
void managedSession.session.abort().catch((error) => {
|
|
this.emit(managedSession, {
|
|
type: "error",
|
|
sessionKey,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
});
|
|
});
|
|
return true;
|
|
}
|
|
|
|
clearQueue(sessionKey: string): void {
|
|
const managedSession = this.sessions.get(sessionKey);
|
|
if (!managedSession) return;
|
|
managedSession.queue.length = 0;
|
|
this.emitState(managedSession);
|
|
}
|
|
|
|
async resetSession(sessionKey: string): Promise<void> {
|
|
const managedSession = this.sessions.get(sessionKey);
|
|
if (!managedSession) return;
|
|
|
|
if (sessionKey === this.primarySessionKey) {
|
|
await managedSession.session.newSession();
|
|
managedSession.queue.length = 0;
|
|
managedSession.processing = false;
|
|
managedSession.lastActiveAt = Date.now();
|
|
this.emitState(managedSession);
|
|
return;
|
|
}
|
|
|
|
if (managedSession.processing) {
|
|
await managedSession.session.abort();
|
|
}
|
|
managedSession.unsubscribe();
|
|
managedSession.session.dispose();
|
|
this.sessions.delete(sessionKey);
|
|
}
|
|
|
|
listSessions(): GatewaySessionSnapshot[] {
|
|
return Array.from(this.sessions.values()).map((session) => this.createSnapshot(session));
|
|
}
|
|
|
|
getSession(sessionKey: string): GatewaySessionSnapshot | undefined {
|
|
const session = this.sessions.get(sessionKey);
|
|
return session ? this.createSnapshot(session) : undefined;
|
|
}
|
|
|
|
private async ensureSession(sessionKey: string, existingSession?: AgentSession): Promise<ManagedGatewaySession> {
|
|
const found = this.sessions.get(sessionKey);
|
|
if (found) {
|
|
found.lastActiveAt = Date.now();
|
|
return found;
|
|
}
|
|
|
|
const session = existingSession ?? (await this.createSession(sessionKey));
|
|
const managedSession: ManagedGatewaySession = {
|
|
sessionKey,
|
|
session,
|
|
queue: [],
|
|
processing: false,
|
|
createdAt: Date.now(),
|
|
lastActiveAt: Date.now(),
|
|
listeners: new Set(),
|
|
unsubscribe: () => {},
|
|
};
|
|
managedSession.unsubscribe = session.subscribe((event) => {
|
|
this.handleSessionEvent(managedSession, event);
|
|
});
|
|
this.sessions.set(sessionKey, managedSession);
|
|
this.emitState(managedSession);
|
|
return managedSession;
|
|
}
|
|
|
|
private async processNext(managedSession: ManagedGatewaySession): Promise<void> {
|
|
if (managedSession.processing || managedSession.queue.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const queued = managedSession.queue.shift();
|
|
if (!queued) return;
|
|
|
|
managedSession.processing = true;
|
|
managedSession.lastActiveAt = Date.now();
|
|
this.emitState(managedSession);
|
|
|
|
try {
|
|
queued.onStart?.();
|
|
await managedSession.session.prompt(queued.request.text, {
|
|
images: queued.request.images,
|
|
source: queued.request.source ?? "extension",
|
|
});
|
|
const response = getLastAssistantText(managedSession.session);
|
|
queued.resolve({
|
|
ok: true,
|
|
response,
|
|
sessionKey: managedSession.sessionKey,
|
|
});
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
if (message.includes("aborted")) {
|
|
this.emit(managedSession, { type: "aborted", sessionKey: managedSession.sessionKey });
|
|
} else {
|
|
this.emit(managedSession, { type: "error", sessionKey: managedSession.sessionKey, error: message });
|
|
}
|
|
queued.resolve({
|
|
ok: false,
|
|
response: "",
|
|
error: message,
|
|
sessionKey: managedSession.sessionKey,
|
|
});
|
|
} finally {
|
|
queued.onFinish?.();
|
|
managedSession.processing = false;
|
|
managedSession.lastActiveAt = Date.now();
|
|
this.emitState(managedSession);
|
|
if (managedSession.queue.length > 0) {
|
|
void this.processNext(managedSession);
|
|
}
|
|
}
|
|
}
|
|
|
|
private handleSessionEvent(managedSession: ManagedGatewaySession, event: AgentSessionEvent): void {
|
|
switch (event.type) {
|
|
case "turn_start":
|
|
this.emit(managedSession, { type: "turn_start", sessionKey: managedSession.sessionKey });
|
|
return;
|
|
case "turn_end":
|
|
this.emit(managedSession, { type: "turn_end", sessionKey: managedSession.sessionKey });
|
|
return;
|
|
case "message_start":
|
|
this.emit(managedSession, {
|
|
type: "message_start",
|
|
sessionKey: managedSession.sessionKey,
|
|
role: event.message.role,
|
|
});
|
|
return;
|
|
case "message_update":
|
|
switch (event.assistantMessageEvent.type) {
|
|
case "text_delta":
|
|
this.emit(managedSession, {
|
|
type: "token",
|
|
sessionKey: managedSession.sessionKey,
|
|
delta: event.assistantMessageEvent.delta,
|
|
contentIndex: event.assistantMessageEvent.contentIndex,
|
|
});
|
|
return;
|
|
case "thinking_delta":
|
|
this.emit(managedSession, {
|
|
type: "thinking",
|
|
sessionKey: managedSession.sessionKey,
|
|
delta: event.assistantMessageEvent.delta,
|
|
contentIndex: event.assistantMessageEvent.contentIndex,
|
|
});
|
|
return;
|
|
}
|
|
return;
|
|
case "message_end":
|
|
if (event.message.role === "assistant") {
|
|
this.emit(managedSession, {
|
|
type: "message_complete",
|
|
sessionKey: managedSession.sessionKey,
|
|
text: extractMessageText(event.message),
|
|
});
|
|
}
|
|
return;
|
|
case "tool_execution_start":
|
|
this.emit(managedSession, {
|
|
type: "tool_start",
|
|
sessionKey: managedSession.sessionKey,
|
|
toolCallId: event.toolCallId,
|
|
toolName: event.toolName,
|
|
args: event.args,
|
|
});
|
|
return;
|
|
case "tool_execution_update":
|
|
this.emit(managedSession, {
|
|
type: "tool_update",
|
|
sessionKey: managedSession.sessionKey,
|
|
toolCallId: event.toolCallId,
|
|
toolName: event.toolName,
|
|
partialResult: event.partialResult,
|
|
});
|
|
return;
|
|
case "tool_execution_end":
|
|
this.emit(managedSession, {
|
|
type: "tool_complete",
|
|
sessionKey: managedSession.sessionKey,
|
|
toolCallId: event.toolCallId,
|
|
toolName: event.toolName,
|
|
result: event.result,
|
|
isError: event.isError,
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
|
|
private emit(managedSession: ManagedGatewaySession, event: GatewayEvent): void {
|
|
for (const listener of managedSession.listeners) {
|
|
listener(event);
|
|
}
|
|
}
|
|
|
|
private emitState(managedSession: ManagedGatewaySession): void {
|
|
this.emit(managedSession, {
|
|
type: "session_state",
|
|
sessionKey: managedSession.sessionKey,
|
|
snapshot: this.createSnapshot(managedSession),
|
|
});
|
|
}
|
|
|
|
private createSnapshot(managedSession: ManagedGatewaySession): GatewaySessionSnapshot {
|
|
return {
|
|
sessionKey: managedSession.sessionKey,
|
|
sessionId: managedSession.session.sessionId,
|
|
messageCount: managedSession.session.messages.length,
|
|
queueDepth: managedSession.queue.length,
|
|
processing: managedSession.processing,
|
|
lastActiveAt: managedSession.lastActiveAt,
|
|
createdAt: managedSession.createdAt,
|
|
};
|
|
}
|
|
|
|
private async evictIdleSessions(): Promise<void> {
|
|
const cutoff = Date.now() - this.config.session.idleMinutes * 60_000;
|
|
for (const [sessionKey, managedSession] of this.sessions) {
|
|
if (sessionKey === this.primarySessionKey) {
|
|
continue;
|
|
}
|
|
if (managedSession.processing || managedSession.queue.length > 0) {
|
|
continue;
|
|
}
|
|
if (managedSession.lastActiveAt > cutoff) {
|
|
continue;
|
|
}
|
|
if (managedSession.listeners.size > 0) {
|
|
continue;
|
|
}
|
|
managedSession.unsubscribe();
|
|
managedSession.session.dispose();
|
|
this.sessions.delete(sessionKey);
|
|
this.log(`evicted idle session ${sessionKey}`);
|
|
}
|
|
}
|
|
|
|
private async handleHttpRequest(request: IncomingMessage, response: ServerResponse): Promise<void> {
|
|
const method = request.method ?? "GET";
|
|
const url = new URL(
|
|
request.url ?? "/",
|
|
`http://${request.headers.host ?? `${this.config.bind}:${this.config.port}`}`,
|
|
);
|
|
const path = url.pathname;
|
|
|
|
if (method === "GET" && path === "/health") {
|
|
this.writeJson(response, 200, { ok: true, ready: this.ready });
|
|
return;
|
|
}
|
|
|
|
if (method === "GET" && path === "/ready") {
|
|
this.requireAuth(request, response);
|
|
if (response.writableEnded) return;
|
|
this.writeJson(response, 200, { ok: true, ready: this.ready, sessions: this.sessions.size });
|
|
return;
|
|
}
|
|
|
|
if (this.config.webhook.enabled && method === "POST" && path.startsWith(this.config.webhook.basePath)) {
|
|
await this.handleWebhookRequest(path, request, response);
|
|
return;
|
|
}
|
|
|
|
this.requireAuth(request, response);
|
|
if (response.writableEnded) return;
|
|
|
|
if (method === "GET" && path === "/sessions") {
|
|
this.writeJson(response, 200, { sessions: this.listSessions() });
|
|
return;
|
|
}
|
|
|
|
const sessionMatch = path.match(/^\/sessions\/([^/]+)(?:\/(events|messages|abort|reset|chat))?$/);
|
|
if (!sessionMatch) {
|
|
this.writeJson(response, 404, { error: "Not found" });
|
|
return;
|
|
}
|
|
|
|
const sessionKey = decodeURIComponent(sessionMatch[1]);
|
|
const action = sessionMatch[2];
|
|
|
|
if (!action && method === "GET") {
|
|
const session = await this.ensureSession(sessionKey);
|
|
this.writeJson(response, 200, { session: this.createSnapshot(session) });
|
|
return;
|
|
}
|
|
|
|
if (action === "events" && method === "GET") {
|
|
await this.handleSse(sessionKey, request, response);
|
|
return;
|
|
}
|
|
|
|
if (action === "chat" && method === "POST") {
|
|
await this.handleChat(sessionKey, request, response);
|
|
return;
|
|
}
|
|
|
|
if (action === "messages" && method === "POST") {
|
|
const body = await this.readJsonBody(request);
|
|
const text = typeof body.text === "string" ? body.text : "";
|
|
if (!text.trim()) {
|
|
this.writeJson(response, 400, { error: "Missing text" });
|
|
return;
|
|
}
|
|
const result = await this.enqueueMessage({
|
|
sessionKey,
|
|
text,
|
|
source: "extension",
|
|
});
|
|
this.writeJson(response, result.ok ? 200 : 500, result);
|
|
return;
|
|
}
|
|
|
|
if (action === "abort" && method === "POST") {
|
|
this.writeJson(response, 200, { ok: this.abortSession(sessionKey) });
|
|
return;
|
|
}
|
|
|
|
if (action === "reset" && method === "POST") {
|
|
await this.resetSession(sessionKey);
|
|
this.writeJson(response, 200, { ok: true });
|
|
return;
|
|
}
|
|
|
|
this.writeJson(response, 405, { error: "Method not allowed" });
|
|
}
|
|
|
|
private async handleWebhookRequest(path: string, request: IncomingMessage, response: ServerResponse): Promise<void> {
|
|
const route = path.slice(this.config.webhook.basePath.length).replace(/^\/+/, "") || "default";
|
|
if (this.config.webhook.secret) {
|
|
const presentedSecret = request.headers["x-pi-webhook-secret"];
|
|
if (presentedSecret !== this.config.webhook.secret) {
|
|
this.writeJson(response, 401, { error: "Invalid webhook secret" });
|
|
return;
|
|
}
|
|
}
|
|
|
|
const body = await this.readJsonBody(request);
|
|
const text = typeof body.text === "string" ? body.text : "";
|
|
if (!text.trim()) {
|
|
this.writeJson(response, 400, { error: "Missing text" });
|
|
return;
|
|
}
|
|
|
|
const conversationId =
|
|
typeof body.sessionKey === "string"
|
|
? body.sessionKey
|
|
: `webhook:${route}:${typeof body.sender === "string" ? body.sender : "default"}`;
|
|
const result = await this.enqueueMessage({
|
|
sessionKey: conversationId,
|
|
text,
|
|
source: "extension",
|
|
metadata: typeof body.metadata === "object" && body.metadata ? (body.metadata as Record<string, unknown>) : {},
|
|
});
|
|
this.writeJson(response, result.ok ? 200 : 500, result);
|
|
}
|
|
|
|
private async handleSse(sessionKey: string, request: IncomingMessage, response: ServerResponse): Promise<void> {
|
|
response.writeHead(200, {
|
|
"Content-Type": "text/event-stream",
|
|
"Cache-Control": "no-cache, no-transform",
|
|
Connection: "keep-alive",
|
|
});
|
|
response.write("\n");
|
|
|
|
const unsubscribe = await this.addSubscriber(sessionKey, (event) => {
|
|
response.write(`data: ${JSON.stringify(event)}\n\n`);
|
|
});
|
|
request.on("close", () => {
|
|
unsubscribe();
|
|
});
|
|
}
|
|
|
|
private async handleChat(sessionKey: string, request: IncomingMessage, response: ServerResponse): Promise<void> {
|
|
const body = await this.readJsonBody(request);
|
|
const text = extractUserText(body);
|
|
if (!text) {
|
|
this.writeJson(response, 400, { error: "Missing user message text" });
|
|
return;
|
|
}
|
|
|
|
// Set up SSE response headers
|
|
response.writeHead(200, {
|
|
"Content-Type": "text/event-stream",
|
|
"Cache-Control": "no-cache, no-transform",
|
|
Connection: "keep-alive",
|
|
"x-vercel-ai-ui-message-stream": "v1",
|
|
});
|
|
response.write("\n");
|
|
|
|
const listener = createVercelStreamListener(response);
|
|
let unsubscribe: (() => void) | undefined;
|
|
let streamingActive = false;
|
|
|
|
const stopStreaming = () => {
|
|
if (!streamingActive) return;
|
|
streamingActive = false;
|
|
unsubscribe?.();
|
|
unsubscribe = undefined;
|
|
};
|
|
|
|
// Clean up on client disconnect
|
|
let clientDisconnected = false;
|
|
request.on("close", () => {
|
|
clientDisconnected = true;
|
|
stopStreaming();
|
|
});
|
|
|
|
// Drive the session through the existing queue infrastructure
|
|
try {
|
|
const managedSession = await this.ensureSession(sessionKey);
|
|
const result = await this.enqueueManagedMessage({
|
|
request: {
|
|
sessionKey,
|
|
text,
|
|
source: "extension",
|
|
},
|
|
onStart: () => {
|
|
if (clientDisconnected || streamingActive) return;
|
|
unsubscribe = managedSession.session.subscribe(listener);
|
|
streamingActive = true;
|
|
},
|
|
onFinish: () => {
|
|
stopStreaming();
|
|
},
|
|
});
|
|
if (!clientDisconnected) {
|
|
stopStreaming();
|
|
if (result.ok) {
|
|
finishVercelStream(response, "stop");
|
|
} else {
|
|
const isAbort = result.error?.includes("aborted");
|
|
if (isAbort) {
|
|
finishVercelStream(response, "error");
|
|
} else {
|
|
errorVercelStream(response, result.error ?? "Unknown error");
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (!clientDisconnected) {
|
|
stopStreaming();
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
errorVercelStream(response, message);
|
|
}
|
|
}
|
|
}
|
|
|
|
private requireAuth(request: IncomingMessage, response: ServerResponse): void {
|
|
if (!this.config.bearerToken) {
|
|
return;
|
|
}
|
|
const header = request.headers.authorization;
|
|
if (header === `Bearer ${this.config.bearerToken}`) {
|
|
return;
|
|
}
|
|
this.writeJson(response, 401, { error: "Unauthorized" });
|
|
}
|
|
|
|
private async readJsonBody(request: IncomingMessage): Promise<Record<string, unknown>> {
|
|
const chunks: Buffer[] = [];
|
|
for await (const chunk of request) {
|
|
chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
|
|
}
|
|
if (chunks.length === 0) {
|
|
return {};
|
|
}
|
|
const body = Buffer.concat(chunks).toString("utf8");
|
|
return JSON.parse(body) as Record<string, unknown>;
|
|
}
|
|
|
|
private writeJson(response: ServerResponse, statusCode: number, payload: unknown): void {
|
|
response.statusCode = statusCode;
|
|
response.setHeader("content-type", "application/json; charset=utf-8");
|
|
response.end(JSON.stringify(payload));
|
|
}
|
|
|
|
getGatewaySessionDir(sessionKey: string): string {
|
|
return join(this.sessionDirRoot, sanitizeSessionKey(sessionKey));
|
|
}
|
|
}
|
|
|
|
function extractMessageText(message: { content: unknown }): string {
|
|
if (!Array.isArray(message.content)) {
|
|
return "";
|
|
}
|
|
return message.content
|
|
.filter((part): part is { type: "text"; text: string } => {
|
|
return typeof part === "object" && part !== null && "type" in part && "text" in part && part.type === "text";
|
|
})
|
|
.map((part) => part.text)
|
|
.join("");
|
|
}
|
|
|
|
function getLastAssistantText(session: AgentSession): string {
|
|
for (let index = session.messages.length - 1; index >= 0; index--) {
|
|
const message = session.messages[index];
|
|
if (message.role === "assistant") {
|
|
return extractMessageText(message);
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
export function sanitizeSessionKey(sessionKey: string): string {
|
|
return sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
|
|
}
|
|
|
|
export function createGatewaySessionManager(cwd: string, sessionKey: string, sessionDirRoot: string): SessionManager {
|
|
return SessionManager.create(cwd, join(sessionDirRoot, sanitizeSessionKey(sessionKey)));
|
|
}
|