@assemblyline-agents/node 1.0.0 → 3.0.0

package/dist/index.js

@@ -1,18 +1,23 @@
 import { createServer } from "node:http";
 import { resolve } from "node:path";
 import { codexAgentHarness } from "@assemblyline-agents/codex";
-import { adapter, applyEnvAliases, mirrorEnvAliasesInPlace } from "@assemblyline-agents/core";
-import { AssemblyLineRuntime, RunCapacityError, loadRuntimeBundle, queryAgentRuns, retryAfterSeconds, validateEvalRunOptions } from "@assemblyline-agents/runtime";
-import { createBlobAdapter, createConnectionStores, createSandboxAdapter, createSelfImprovementStores, createStateAdapter, loadRunTimeline } from "./adapters.js";
+import { adapter, ConnectionEventError } from "@assemblyline-agents/core";
+import { AssemblyLineRuntime, RunReplayError, RunCapacityError, durableAgentScopeForManifest, loadRuntimeBundle, queryAgentRuns, retryAfterSeconds, validateEvalRunOptions } from "@assemblyline-agents/runtime";
+import { deleteMemoryAdmin, listMemoryAdmin, parseMemoryAdminRoute, readMemoryAdmin } from "./memory-admin-http.js";
+import { createBlobAdapter, createConnectionStores, createMediaProcessors, createSandboxAdapter, createSelfImprovementStores, createStateAdapter, loadRunTimeline, loadRunTimelinePage } from "./adapters.js";
 import { apiRunCreationEnabled, evalRunsEnabled, authorizeOrSend, logHttpRequest, numberBodyValue, numberQueryValue, rateLimitOrSend, stringBodyValue, validateRuntimeHttpSecurity } from "./auth.js";
 import { HttpRequestError, firstHeaderValue, maxRequestBodyBytes, normalizeHeaders, readBody, send, summarizeRun } from "./http-io.js";
 import { serveRunEventStream, serveStreamingRun } from "./run-stream-http.js";
-import { matchRoute, parseAgentControlRoute, parseRunResumeRoute, parseRunRoute } from "./route-match.js";
+import { resolveSecretsEnv } from "./secrets.js";
+import { startRunReplay } from "./run-replay-http.js";
+import { matchRoute, parseAgentControlRoute, parseRunFeedbackRoute, parseRunReplayRoute, parseRunResumeRoute, parseRunRoute, parseSelfImprovementRoute } from "./route-match.js";
 import { resolveIngressRateLimit } from "./rate-limit.js";
 import { createNodeRuntimeHandle, installSignalHandlers } from "./lifecycle.js";
 import { DIRECT_CHANNEL, conversationBelongsToAgent, decodeConversationCursor, decodeMessageCursor, directAgentScope, directConversationPatch, directTurnFromBody, encodeConversationCursor, encodeMessageCursor, parseConversationHttpRoute } from "./direct-conversations-http.js";
 import { usageHttpResult, usageReconciliationHttpResult } from "./usage-http.js";
+import { isWorkspaceAdminPath, workspaceAdminHttpResult } from "./workspace-admin-http.js";
 export { resolveProvider } from "./provider-resolver.js";
+export { resolveSecretsEnv } from "./secrets.js";
 export { createMemoryRateLimiterStore, parseRateLimitSpec, resolveIngressRateLimit } from "./rate-limit.js";
 export { createNodeRuntimeHandle, installSignalHandlers } from "./lifecycle.js";
 export function nodeAdapter(options = {}) {
@@ -34,11 +39,17 @@ export function withNodeModelHarnesses(options) {
 }
 export async function createProductionRuntimeOptions(options) {
     const artifactRoot = resolve(options.artifactRoot);
-    const env = options.env ?? process.env;
     const runtimeOptions = loadRuntimeBundle(artifactRoot);
     runtimeOptions.devMode = options.devMode ?? false;
+    const env = await resolveSecretsEnv({
+        manifest: runtimeOptions.manifest,
+        env: options.env ?? process.env,
+        artifactRoot,
+        devMode: options.devMode ?? false
+    });
     const state = await createStateAdapter(runtimeOptions, artifactRoot, env);
     const blob = await createBlobAdapter(runtimeOptions, artifactRoot, env);
+    const mediaProcessors = await createMediaProcessors(runtimeOptions, artifactRoot, env);
     const connectionStores = createConnectionStores(runtimeOptions, artifactRoot, env, state, options.devMode ?? false);
     const selfImprovementStores = createSelfImprovementStores(artifactRoot, env, state);
     const sandbox = await createSandboxAdapter(runtimeOptions, artifactRoot, env);
@@ -46,20 +57,23 @@ export async function createProductionRuntimeOptions(options) {
         ...runtimeOptions,
         state,
         blob,
+        mediaProcessors,
         sandbox,
         connectionGrantStore: connectionStores.grantStore,
         connectionAuthorizationSessionStore: connectionStores.authorizationSessionStore,
+        connectionEventStore: connectionStores.eventStore,
         skillStore: selfImprovementStores.skillStore,
+        learningStore: selfImprovementStores.learningStore,
         scheduleStore: selfImprovementStores.scheduleStore,
         connectionDefinitionStore: selfImprovementStores.connectionDefinitionStore,
         env,
         devMode: options.devMode ?? false
     };
-    const callbackBaseUrl = env.OPENEVE_CONNECTION_CALLBACK_BASE_URL ?? env.OPENEVE_PUBLIC_URL;
+    const callbackBaseUrl = env.ASSEMBLY_LINE_CONNECTION_CALLBACK_BASE_URL ?? env.ASSEMBLY_LINE_PUBLIC_URL;
     if (callbackBaseUrl)
         out.connectionCallbackBaseUrl = callbackBaseUrl;
     // Production default: bound run concurrency unless the operator chose a limit.
-    if (!(options.devMode ?? false) && env.OPENEVE_MAX_CONCURRENT_RUNS === undefined) {
+    if (!(options.devMode ?? false) && env.ASSEMBLY_LINE_MAX_CONCURRENT_RUNS === undefined) {
         out.maxConcurrentRuns = 16;
     }
     return withNodeModelHarnesses(out);
@@ -87,7 +101,7 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
             if (request.method === "GET" && url.pathname === "/health") {
                 if (!await authorizeOrSend(request, response, runtime, options, "public-health", url.pathname))
                     return;
-                send(response, 200, { ok: true, agentRevision: options.manifest.agentRevision });
+                send(response, 200, revisionHealth(options.manifest));
                 return;
             }
             if (request.method === "GET" && url.pathname === "/healthz") {
@@ -96,6 +110,7 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 send(response, 200, {
                     ok: true,
                     agentRevision: options.manifest.agentRevision,
+                    buildRevision: options.manifest.buildRevision ?? options.manifest.agentRevision,
                     capabilities: evalRunsEnabled(runtime, options) ? ["eval-runs"] : []
                 });
                 return;
@@ -106,10 +121,10 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 if (!await authorizeOrSend(request, response, runtime, options, "public-health", url.pathname))
                     return;
                 if (drain.draining) {
-                    send(response, 503, { ok: false, draining: true });
+                    send(response, 503, { ...revisionHealth(options.manifest), ok: false, draining: true });
                     return;
                 }
-                send(response, 200, { ok: true, agentRevision: options.manifest.agentRevision });
+                send(response, 200, revisionHealth(options.manifest));
                 return;
             }
             if (request.method === "GET" && url.pathname === "/manifest") {
@@ -148,6 +163,25 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 send(response, 200, result);
                 return;
             }
+            if (isWorkspaceAdminPath(url.pathname)) {
+                const method = request.method ?? "GET";
+                if (!["GET", "POST", "DELETE"].includes(method)) {
+                    send(response, 405, { error: "Method not allowed." });
+                    return;
+                }
+                if (!await authorizeOrSend(request, response, runtime, options, method === "GET" ? "admin-read" : "agent-control", url.pathname))
+                    return;
+                try {
+                    const body = method === "POST"
+                        ? (await readBody(request, maxRequestBodyBytes(runtime, options))).body
+                        : {};
+                    send(response, 200, await workspaceAdminHttpResult(runtime, method, url.pathname, body, url.searchParams));
+                }
+                catch (error) {
+                    send(response, 400, { error: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
             const conversationRoute = parseConversationHttpRoute(url.pathname);
             if (conversationRoute?.kind === "collection" && request.method === "GET") {
                 if (!await authorizeOrSend(request, response, runtime, options, "admin-read", url.pathname))
@@ -276,14 +310,21 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                     send(response, 400, { error: "A message or attachment is required." });
                     return;
                 }
+                const workspaceId = stringBodyValue(body.workspaceId);
+                const projectId = stringBodyValue(body.projectId);
+                const tenantId = stringBodyValue(body.tenantId);
                 const runOptions = {
                     message: direct.turn.message,
                     channel: DIRECT_CHANNEL,
                     approve: direct.approve,
-                    turn: direct.turn
+                    turn: direct.turn,
+                    ...(workspaceId ? { workspaceId } : {}),
+                    ...(projectId ? { projectId } : {}),
+                    ...(tenantId ? { tenantId } : {})
                 };
-                if (direct.turn.model)
-                    Object.assign(runOptions, { model: direct.turn.model });
+                if (body.sandboxCredentials && typeof body.sandboxCredentials === "object" && !Array.isArray(body.sandboxCredentials)) {
+                    Object.assign(runOptions, { sandboxCredentials: body.sandboxCredentials });
+                }
                 try {
                     if (direct.stream) {
                         await serveStreamingRun(runtime, response, (onRunCreated) => runtime.run({ ...runOptions, onRunCreated }), (result) => summarizeRun(result));
@@ -313,6 +354,104 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 send(response, 200, await queryAgentRuns(runtime.state, options.manifest, { includeDetails: false, limit }));
                 return;
             }
+            const memoryAdminRoute = parseMemoryAdminRoute(url.pathname);
+            if (memoryAdminRoute) {
+                const agentScope = durableAgentScopeForManifest(options.manifest);
+                if (request.method === "GET") {
+                    if (!await authorizeOrSend(request, response, runtime, options, "admin-read", url.pathname))
+                        return;
+                    const result = memoryAdminRoute.kind === "list"
+                        ? await listMemoryAdmin(runtime.state, agentScope, url.searchParams)
+                        : await readMemoryAdmin(runtime.state, agentScope, memoryAdminRoute.path);
+                    send(response, result.status, result.body);
+                    return;
+                }
+                if (request.method === "DELETE" && memoryAdminRoute.kind === "document") {
+                    if (!await authorizeOrSend(request, response, runtime, options, "agent-control", url.pathname))
+                        return;
+                    if (!await rateLimitOrSend(request, response, rateLimit, "agent-control", url.pathname))
+                        return;
+                    const result = await deleteMemoryAdmin(runtime.state, agentScope, memoryAdminRoute.path, url.searchParams);
+                    send(response, result.status, result.body);
+                    return;
+                }
+                send(response, 405, { error: "Method not allowed." });
+                return;
+            }
+            const selfImprovementRoute = parseSelfImprovementRoute(url.pathname);
+            const selfImprovementSurface = url.searchParams.get("surface")?.trim() || "root";
+            if (selfImprovementRoute && request.method === "GET") {
+                if (!await authorizeOrSend(request, response, runtime, options, "admin-read", url.pathname))
+                    return;
+                if (selfImprovementRoute.kind === "pending") {
+                    send(response, 200, { surface: selfImprovementSurface, changes: await runtime.listPendingSkillChanges(selfImprovementSurface) });
+                    return;
+                }
+                if (selfImprovementRoute.kind === "reviews") {
+                    send(response, 200, { surface: selfImprovementSurface, reviews: await runtime.listBackgroundReviews(selfImprovementSurface) });
+                    return;
+                }
+                if (selfImprovementRoute.kind === "revisions") {
+                    send(response, 200, { surface: selfImprovementSurface, name: selfImprovementRoute.name, revisions: await runtime.listSkillRevisions(selfImprovementRoute.name, selfImprovementSurface) });
+                    return;
+                }
+                send(response, 405, { error: "Method not allowed." });
+                return;
+            }
+            if (selfImprovementRoute && request.method === "POST") {
+                if (!await authorizeOrSend(request, response, runtime, options, "agent-control", url.pathname))
+                    return;
+                if (!await rateLimitOrSend(request, response, rateLimit, "agent-control", url.pathname))
+                    return;
+                if (selfImprovementRoute.kind === "approve") {
+                    try {
+                        send(response, 200, await runtime.approveSkillChange(selfImprovementRoute.id, selfImprovementSurface));
+                    }
+                    catch (error) {
+                        if (error instanceof Error && /not found/i.test(error.message)) {
+                            send(response, 404, { error: error.message });
+                            return;
+                        }
+                        throw error;
+                    }
+                    return;
+                }
+                if (selfImprovementRoute.kind === "reject") {
+                    try {
+                        await runtime.rejectSkillChange(selfImprovementRoute.id, selfImprovementSurface);
+                        send(response, 200, { rejected: true, id: selfImprovementRoute.id, surface: selfImprovementSurface });
+                    }
+                    catch (error) {
+                        if (error instanceof Error && /not found/i.test(error.message)) {
+                            send(response, 404, { error: error.message });
+                            return;
+                        }
+                        throw error;
+                    }
+                    return;
+                }
+                if (selfImprovementRoute.kind === "restore") {
+                    const { body } = await readBody(request, maxRequestBodyBytes(runtime, options));
+                    const revision = numberBodyValue(body.revision);
+                    if (revision === undefined || revision < 1 || !Number.isInteger(revision)) {
+                        send(response, 400, { error: "A positive integer revision is required." });
+                        return;
+                    }
+                    try {
+                        send(response, 200, await runtime.restoreSkillRevision(selfImprovementRoute.name, revision, selfImprovementSurface));
+                    }
+                    catch (error) {
+                        if (error instanceof Error && /not found/i.test(error.message)) {
+                            send(response, 404, { error: error.message });
+                            return;
+                        }
+                        throw error;
+                    }
+                    return;
+                }
+                send(response, 405, { error: "Method not allowed." });
+                return;
+            }
             if (request.method === "GET" && url.pathname === "/usage") {
                 if (!await authorizeOrSend(request, response, runtime, options, "admin-read", url.pathname))
                     return;
@@ -404,6 +543,31 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 send(response, 200, { ok: true, matched: results.length, results });
                 return;
             }
+            if (request.method === "POST" && url.pathname === "/assembly-line/connections/events/reconcile") {
+                if (!await authorizeOrSend(request, response, runtime, options, "agent-control", url.pathname))
+                    return;
+                const { body } = await readBody(request, maxRequestBodyBytes(runtime, options));
+                const principal = stringBodyValue(body.userId) && stringBodyValue(body.issuer)
+                    ? { type: "user", id: stringBodyValue(body.userId), issuer: stringBodyValue(body.issuer) }
+                    : undefined;
+                const connection = stringBodyValue(body.connection);
+                const publicUrl = stringBodyValue(body.publicUrl);
+                const results = await runtime.reconcileConnectionEvents({
+                    ...(connection ? { connection } : {}),
+                    ...(publicUrl ? { publicUrl } : {}),
+                    ...(principal ? { principal } : {}),
+                    force: body.force === true
+                });
+                send(response, 200, { ok: true, results });
+                return;
+            }
+            if (request.method === "GET" && url.pathname === "/assembly-line/connections/events") {
+                if (!await authorizeOrSend(request, response, runtime, options, "admin-read", url.pathname))
+                    return;
+                const results = await runtime.checkConnectionEvents(url.searchParams.get("connection") ?? undefined);
+                send(response, 200, { ok: true, results });
+                return;
+            }
             if (request.method === "GET" && url.pathname.startsWith("/runs/")) {
                 if (!await authorizeOrSend(request, response, runtime, options, "admin-read", url.pathname))
                     return;
@@ -421,7 +585,30 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                     await serveRunEventStream(runtime, response, runRoute.runId, lastEventId);
                     return;
                 }
-                const timeline = await loadRunTimeline(runtime, runRoute.runId);
+                const paginatedTimeline = runRoute.kind === "timeline" && url.searchParams.has("limit");
+                const before = numberQueryValue(url.searchParams.get("before"));
+                const after = numberQueryValue(url.searchParams.get("after"));
+                const limit = numberQueryValue(url.searchParams.get("limit"));
+                if (paginatedTimeline && limit === undefined) {
+                    send(response, 400, { error: "Run timeline limit must be a number." });
+                    return;
+                }
+                let timeline;
+                try {
+                    timeline = paginatedTimeline
+                        ? await loadRunTimelinePage(runtime, runRoute.runId, {
+                            ...(before !== undefined ? { before } : {}),
+                            ...(after !== undefined ? { after } : {}),
+                            limit: limit
+                        })
+                        : await loadRunTimeline(runtime, runRoute.runId);
+                }
+                catch (error) {
+                    if (!paginatedTimeline)
+                        throw error;
+                    send(response, 400, { error: error instanceof Error ? error.message : String(error) });
+                    return;
+                }
                 if (!timeline) {
                     send(response, 404, { error: `Run not found: ${runRoute.runId}` });
                     return;
@@ -438,6 +625,62 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 return;
             }
             if (request.method === "POST" && url.pathname.startsWith("/runs/")) {
+                const replayRoute = parseRunReplayRoute(url.pathname);
+                if (replayRoute) {
+                    if (!await authorizeOrSend(request, response, runtime, options, "agent-control", url.pathname))
+                        return;
+                    if (!await rateLimitOrSend(request, response, rateLimit, "run-create", url.pathname))
+                        return;
+                    try {
+                        const replay = await startRunReplay(runtime, replayRoute.runId);
+                        void replay.completion.catch((error) => {
+                            runtime.logger.error("replay run failed after durable creation", {
+                                sourceRunId: replayRoute.runId,
+                                runId: replay.run.id,
+                                error: error instanceof Error ? error.message : String(error)
+                            });
+                        });
+                        send(response, 202, { runId: replay.run.id, status: replay.run.status });
+                    }
+                    catch (error) {
+                        if (error instanceof RunReplayError) {
+                            send(response, error.code === "run_not_found" ? 404 : 409, { error: error.message, code: error.code });
+                            return;
+                        }
+                        if (error instanceof RunCapacityError) {
+                            send(response, 429, { error: "Run capacity exhausted. Retry later.", retryAfterMs: error.retryAfterMs }, {
+                                "retry-after": String(retryAfterSeconds(error.retryAfterMs))
+                            });
+                            return;
+                        }
+                        throw error;
+                    }
+                    return;
+                }
+                const feedbackRoute = parseRunFeedbackRoute(url.pathname);
+                if (feedbackRoute) {
+                    if (!await authorizeOrSend(request, response, runtime, options, "run-control", url.pathname))
+                        return;
+                    if (!await rateLimitOrSend(request, response, rateLimit, "run-control", url.pathname))
+                        return;
+                    if (!await runtime.state.getRun(feedbackRoute.runId)) {
+                        send(response, 404, { error: `Run not found: ${feedbackRoute.runId}` });
+                        return;
+                    }
+                    const { body } = await readBody(request, maxRequestBodyBytes(runtime, options));
+                    const rating = stringBodyValue(body.rating);
+                    const comment = stringBodyValue(body.comment);
+                    if (rating !== "positive" && rating !== "negative") {
+                        send(response, 400, { error: "Feedback rating must be 'positive' or 'negative'." });
+                        return;
+                    }
+                    const result = await runtime.recordRunFeedback(feedbackRoute.runId, {
+                        rating,
+                        ...(comment ? { comment } : {})
+                    });
+                    send(response, 202, result);
+                    return;
+                }
                 const resumeRoute = parseRunResumeRoute(url.pathname);
                 if (resumeRoute) {
                     const isHitlResume = resumeRoute.kind === "approve" || resumeRoute.kind === "answer";
@@ -464,7 +707,18 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                         send(response, 409, { error: `Run ${resumeRoute.runId} is not ${expected} (status: ${run.status}).` });
                         return;
                     }
-                    if (resumeRoute.kind === "cancel" && ["completed", "failed", "cancelled"].includes(run.status)) {
+                    if (resumeRoute.kind === "cancel" && run.status === "cancelled") {
+                        // Cancellation is an idempotent operator command. A retry may be
+                        // the first response the client receives even when an earlier
+                        // request already committed the terminal state.
+                        send(response, 200, {
+                            runId: run.id,
+                            status: run.status,
+                            controlIntent: run.controlIntent ?? null
+                        });
+                        return;
+                    }
+                    if (resumeRoute.kind === "cancel" && ["completed", "failed"].includes(run.status)) {
                         send(response, 409, { error: `Run ${resumeRoute.runId} is already terminal (status: ${run.status}).` });
                         return;
                     }
@@ -505,6 +759,17 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                         }
                         // The resume idempotency claim rejects a concurrent/replayed resume.
                         const message = error instanceof Error ? error.message : String(error);
+                        if (resumeRoute.kind === "cancel" && /already terminal/i.test(message)) {
+                            const latest = await runtime.state.getRun(resumeRoute.runId);
+                            if (latest?.status === "cancelled") {
+                                send(response, 200, {
+                                    runId: latest.id,
+                                    status: latest.status,
+                                    controlIntent: latest.controlIntent ?? null
+                                });
+                                return;
+                            }
+                        }
                         if (/already in progress|not waiting|not suspended|not running|already terminal/i.test(message)) {
                             send(response, 409, { error: message });
                             return;
@@ -532,11 +797,15 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 const session = {};
                 const sessionChannel = url.searchParams.get("channel");
                 const sessionUserId = url.searchParams.get("userId");
+                const sessionIssuer = url.searchParams.get("issuer");
                 const sessionConversationId = url.searchParams.get("conversationId");
                 if (sessionChannel)
                     session.channel = sessionChannel;
                 if (sessionUserId)
                     session.userId = sessionUserId;
+                if (sessionUserId && sessionIssuer) {
+                    session.principal = { type: "user", id: sessionUserId, issuer: sessionIssuer };
+                }
                 if (sessionConversationId)
                     session.conversationId = sessionConversationId;
                 const result = await runtime.beginConnectionAuthorization(connectionName, session);
@@ -564,6 +833,33 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                 send(response, result.status, result.body);
                 return;
             }
+            const connectionEvent = /^\/assembly-line\/connections\/([^/]+)\/events\/([^/]+)$/u.exec(url.pathname);
+            if ((request.method === "GET" || request.method === "POST") && connectionEvent?.[1] && connectionEvent[2]) {
+                if (!await authorizeOrSend(request, response, runtime, options, "connection-event", url.pathname))
+                    return;
+                if (!await rateLimitOrSend(request, response, rateLimit, "connection-event", url.pathname))
+                    return;
+                const rawBody = request.method === "POST"
+                    ? (await readBody(request, maxRequestBodyBytes(runtime, options))).rawBody
+                    : "";
+                try {
+                    const result = await runtime.acceptConnectionEvent(decodeURIComponent(connectionEvent[1]), decodeURIComponent(connectionEvent[2]), {
+                        method: request.method,
+                        headers: normalizeHeaders(request.headers),
+                        body: rawBody,
+                        query: Object.fromEntries(url.searchParams.entries())
+                    });
+                    send(response, result.status, result.body ?? { ok: true, accepted: result.accepted, duplicates: result.duplicates, ignored: result.ignored }, result.headers);
+                }
+                catch (error) {
+                    if (error instanceof ConnectionEventError) {
+                        send(response, error.status, { error: error.message });
+                        return;
+                    }
+                    throw error;
+                }
+                return;
+            }
             if (request.method === "POST" && url.pathname === "/runs") {
                 if (!apiRunCreationEnabled(runtime, options)) {
                     send(response, 403, { error: "API run creation is disabled." });
@@ -579,15 +875,26 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
                     approve: body.approve === true,
                     channel: typeof body.channel === "string" ? body.channel : "http"
                 };
-                if (typeof body.model === "string")
-                    Object.assign(runOptions, { model: body.model });
                 if (typeof body.toolName === "string")
                     Object.assign(runOptions, { toolName: body.toolName });
                 if (body.input !== undefined)
                     Object.assign(runOptions, { input: body.input });
+                if (typeof body.conversationId === "string")
+                    Object.assign(runOptions, { conversationId: body.conversationId });
+                if (typeof body.projectId === "string")
+                    Object.assign(runOptions, { projectId: body.projectId });
+                if (typeof body.workspaceId === "string")
+                    Object.assign(runOptions, { workspaceId: body.workspaceId });
+                if (typeof body.tenantId === "string")
+                    Object.assign(runOptions, { tenantId: body.tenantId });
+                if (typeof body.userId === "string")
+                    Object.assign(runOptions, { userId: body.userId });
+                if (body.sandboxCredentials && typeof body.sandboxCredentials === "object" && !Array.isArray(body.sandboxCredentials)) {
+                    Object.assign(runOptions, { sandboxCredentials: body.sandboxCredentials });
+                }
                 if (body.eval !== undefined) {
                     if (!evalRunsEnabled(runtime, options)) {
-                        send(response, 403, { error: "Eval run options are disabled. Set OPENEVE_ENABLE_EVAL_RUNS=true or allowEvalRuns." });
+                        send(response, 403, { error: "Eval run options are disabled. Set ASSEMBLY_LINE_ENABLE_EVAL_RUNS=true or allowEvalRuns." });
                         return;
                     }
                     try {
@@ -659,14 +966,7 @@ function createNodeRuntimeServerForRuntime(runtime, options, drain = { draining:
         }
     });
 }
-export async function listenNodeRuntime(rawOptions) {
-    // Rename compatibility: make every branded env var readable under both its
-    // ASSEMBLY_LINE_* and OPENEVE_* spellings for all downstream readers.
-    const options = rawOptions.env
-        ? { ...rawOptions, env: applyEnvAliases(rawOptions.env).env }
-        : rawOptions;
-    if (!rawOptions.env)
-        mirrorEnvAliasesInPlace(process.env);
+export async function listenNodeRuntime(options) {
     const runtime = new AssemblyLineRuntime(withNodeModelHarnesses(options));
     runtime.boot();
     validateRuntimeHttpSecurity(runtime, options);
@@ -685,7 +985,7 @@ export async function listenNodeRuntime(rawOptions) {
     if (scheduler)
         server.once("close", stopScheduler);
     const env = options.env ?? runtime.env ?? process.env;
-    if (env.OPENEVE_RUN_RECOVERY !== "false" && env.OPENEVE_RUN_RECOVERY !== "0") {
+    if (env.ASSEMBLY_LINE_RUN_RECOVERY !== "false" && env.ASSEMBLY_LINE_RUN_RECOVERY !== "0") {
         // Repair runs orphaned by a previous process before accepting new traffic.
         await runtime.recoverIncompleteRuns().catch((error) => {
             runtime.logger.warn("boot run recovery failed", {
@@ -720,14 +1020,21 @@ export async function listenNodeRuntime(rawOptions) {
     // Hosts like Railway send SIGTERM on every redeploy/restart. With no handler
     // installed, Node terminates immediately and the graceful drain never runs, so
     // in-flight runs are orphaned. Install the handlers by default (opt-out via
-    // option or OPENEVE_SIGNAL_HANDLERS) so redeploys drain instead of hard-kill.
+    // option or ASSEMBLY_LINE_SIGNAL_HANDLERS) so redeploys drain instead of hard-kill.
     if (options.installSignalHandlers !== false &&
-        env.OPENEVE_SIGNAL_HANDLERS !== "false" &&
-        env.OPENEVE_SIGNAL_HANDLERS !== "0") {
+        env.ASSEMBLY_LINE_SIGNAL_HANDLERS !== "false" &&
+        env.ASSEMBLY_LINE_SIGNAL_HANDLERS !== "0") {
         installSignalHandlers(handle);
     }
     return handle;
 }
+function revisionHealth(manifest) {
+    return {
+        ok: true,
+        agentRevision: manifest.agentRevision,
+        buildRevision: manifest.buildRevision ?? manifest.agentRevision
+    };
+}
 function once(fn) {
     let done = false;
     return () => {