@seele00/seele 0.1.63 → 0.1.64

package/server/dist/runtime-worker/process.js

@@ -1,216 +0,0 @@
-import { readRuntimeThread, rebuildRuntimeThread, listRuntimeModels, readRuntimeRateLimits, runStreamedTurn, } from "../codex-runtime/run-streamed-turn.js";
-const activeTurns = new Map();
-const heartbeatTimers = new Map();
-process.on("message", (message) => {
-    void handleMessage(message).catch((error) => {
-        send({
-            type: "turn.worker_error",
-            message: error instanceof Error ? error.message : String(error),
-        });
-    });
-});
-async function handleMessage(message) {
-    if (message.type === "runtime.rate_limits.read") {
-        const { operationId, config } = message.payload;
-        try {
-            const result = await readRuntimeRateLimits(config);
-            send({
-                type: "runtime.rate_limits.read.completed",
-                operationId,
-                result,
-            });
-        }
-        catch (error) {
-            send({
-                type: "runtime.operation_failed",
-                operationId,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            scheduleExit();
-        }
-        return;
-    }
-    if (message.type === "runtime.models.list") {
-        const { operationId, config } = message.payload;
-        try {
-            const result = await listRuntimeModels(config);
-            send({
-                type: "runtime.models.list.completed",
-                operationId,
-                result,
-            });
-        }
-        catch (error) {
-            send({
-                type: "runtime.operation_failed",
-                operationId,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            scheduleExit();
-        }
-        return;
-    }
-    if (message.type === "thread.read") {
-        const { operationId, config, request } = message.payload;
-        try {
-            const result = await readRuntimeThread(config, request);
-            send({
-                type: "thread.read.completed",
-                operationId,
-                result,
-            });
-        }
-        catch (error) {
-            send({
-                type: "runtime.operation_failed",
-                operationId,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            scheduleExit();
-        }
-        return;
-    }
-    if (message.type === "thread.rebuild") {
-        const { operationId, config, request, injectedItems } = message.payload;
-        try {
-            const result = await rebuildRuntimeThread(config, request, injectedItems);
-            send({
-                type: "thread.rebuild.completed",
-                operationId,
-                result,
-            });
-        }
-        catch (error) {
-            send({
-                type: "runtime.operation_failed",
-                operationId,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            scheduleExit();
-        }
-        return;
-    }
-    if (message.type === "turn.start") {
-        const { turnId, config, request } = message.payload;
-        send({
-            type: "worker.ready",
-            turnId,
-        });
-        startHeartbeat(turnId);
-        try {
-            const result = await runStreamedTurn(config, request, undefined, {
-                onEvent: (event, data) => send({
-                    type: "turn.event",
-                    turnId,
-                    event,
-                    data,
-                }),
-                onActiveTurn: (control) => activeTurns.set(turnId, control),
-                onInactiveTurn: (control) => {
-                    if (activeTurns.get(turnId) === control) {
-                        activeTurns.delete(turnId);
-                    }
-                },
-            });
-            if (result) {
-                send({
-                    type: "turn.completed",
-                    turnId,
-                    result,
-                });
-            }
-            else {
-                send({
-                    type: "turn.failed",
-                    turnId,
-                    message: "Codex turn failed",
-                });
-            }
-        }
-        catch (error) {
-            send({
-                type: "turn.failed",
-                turnId,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-        finally {
-            activeTurns.delete(turnId);
-            stopHeartbeat(turnId);
-            scheduleExit();
-        }
-        return;
-    }
-    if (message.type === "turn.stop") {
-        const control = activeTurns.get(message.payload.turnId);
-        if (!control) {
-            send({
-                type: "turn.worker_error",
-                turnId: message.payload.turnId,
-                message: "turn_not_running",
-            });
-            return;
-        }
-        await control.stop();
-        return;
-    }
-    if (message.type === "turn.steer") {
-        const control = activeTurns.get(message.payload.turnId);
-        if (!control) {
-            send({
-                type: "turn.worker_error",
-                turnId: message.payload.turnId,
-                message: "turn_not_running",
-            });
-            return;
-        }
-        await control.steer(message.payload.message);
-        return;
-    }
-    if (message.type === "turn.approval.respond") {
-        const control = activeTurns.get(message.payload.turnId);
-        if (!control) {
-            send({
-                type: "turn.worker_error",
-                turnId: message.payload.turnId,
-                message: "turn_not_running",
-            });
-            return;
-        }
-        control.respondApproval(message.payload.requestId, message.payload.decision);
-    }
-}
-function send(message) {
-    process.send?.(message);
-}
-function scheduleExit() {
-    setTimeout(() => process.exit(0), 10).unref();
-}
-function startHeartbeat(turnId) {
-    stopHeartbeat(turnId);
-    const timer = setInterval(() => {
-        send({
-            type: "worker.heartbeat",
-            turnId,
-            activeTurnCount: activeTurns.size,
-        });
-    }, 5_000);
-    timer.unref?.();
-    heartbeatTimers.set(turnId, timer);
-}
-function stopHeartbeat(turnId) {
-    const timer = heartbeatTimers.get(turnId);
-    if (!timer) {
-        return;
-    }
-    clearInterval(timer);
-    heartbeatTimers.delete(turnId);
-}

package/server/dist/runtime-worker/protocol.js

@@ -1 +0,0 @@
-export {};