@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/runtime/harness/run/run-queue.js

@@ -1,43 +1 @@
-export function enqueuePendingRequestSlot(pendingRequestSlots, entry, insertionOrder) {
-    const previousPositions = new Map(pendingRequestSlots
-        .filter((candidate) => Boolean(candidate.sessionId && candidate.requestId))
-        .map((candidate, index) => [candidate.requestId, index + 1]));
-    pendingRequestSlots.push({
-        ...entry,
-        insertionOrder,
-    });
-    pendingRequestSlots.sort((left, right) => {
-        if (right.priority !== left.priority) {
-            return right.priority - left.priority;
-        }
-        return left.insertionOrder - right.insertionOrder;
-    });
-    return pendingRequestSlots.flatMap((candidate, index) => {
-        if (!candidate.sessionId || !candidate.requestId) {
-            return [];
-        }
-        const previousPosition = previousPositions.get(candidate.requestId);
-        const queuePosition = index + 1;
-        if (previousPosition === undefined || previousPosition === queuePosition) {
-            return [];
-        }
-        return [{
-                sessionId: candidate.sessionId,
-                requestId: candidate.requestId,
-                priority: candidate.priority,
-                queuePosition,
-            }];
-    });
-}
-export function shiftNextPendingRequestSlot(pendingRequestSlots) {
-    return pendingRequestSlots.shift();
-}
-export function dropPendingRequestSlot(pendingRequestSlots, requestId) {
-    const index = pendingRequestSlots.findIndex((entry) => entry.requestId === requestId);
-    if (index < 0) {
-        return false;
-    }
-    const [entry] = pendingRequestSlots.splice(index, 1);
-    entry?.abort();
-    return true;
-}
+function p(e,i,o){const s=new Map(e.filter(r=>!!(r.sessionId&&r.requestId)).map((r,t)=>[r.requestId,t+1]));return e.push({...i,insertionOrder:o}),e.sort((r,t)=>t.priority!==r.priority?t.priority-r.priority:r.insertionOrder-t.insertionOrder),e.flatMap((r,t)=>{if(!r.sessionId||!r.requestId)return[];const n=s.get(r.requestId),u=t+1;return n===void 0||n===u?[]:[{sessionId:r.sessionId,requestId:r.requestId,priority:r.priority,queuePosition:u}]})}function f(e){return e.shift()}function I(e,i){const o=e.findIndex(r=>r.requestId===i);if(o<0)return!1;const[s]=e.splice(o,1);return s?.abort(),!0}export{I as dropPendingRequestSlot,p as enqueuePendingRequestSlot,f as shiftNextPendingRequestSlot};

package/dist/runtime/harness/run/run-slot-acquisition.js

@@ -1,157 +1 @@
-import { shiftNextPendingRequestSlot } from "./run-queue.js";
-export async function acquireRequestSlot(runtime, options = {}) {
-    const { sessionId, requestId } = options;
-    const activeState = options.activeState ?? "running";
-    const priority = options.priority ?? 0;
-    let stopHeartbeat = () => undefined;
-    const beginLease = async (mode) => {
-        if (!sessionId || !requestId) {
-            return;
-        }
-        const claimedAt = new Date().toISOString();
-        const leaseExpiresAt = new Date(Date.now() + runtime.concurrencyConfig.leaseMs).toISOString();
-        if (mode === "queue-claim") {
-            await runtime.persistence.claimQueuedRequest({
-                sessionId,
-                requestId,
-                workerId: runtime.workerId,
-                claimedAt,
-                leaseExpiresAt,
-            });
-        }
-        else {
-            await runtime.persistence.renewRequestLease({
-                requestId,
-                workerId: runtime.workerId,
-                heartbeatAt: claimedAt,
-                leaseExpiresAt,
-            });
-        }
-        if (runtime.concurrencyConfig.heartbeatIntervalMs <= 0) {
-            return;
-        }
-        const timer = setInterval(() => {
-            void runtime.persistence.renewRequestLease({
-                requestId,
-                workerId: runtime.workerId,
-                heartbeatAt: new Date().toISOString(),
-                leaseExpiresAt: new Date(Date.now() + runtime.concurrencyConfig.leaseMs).toISOString(),
-            });
-        }, runtime.concurrencyConfig.heartbeatIntervalMs);
-        timer.unref?.();
-        stopHeartbeat = () => {
-            clearInterval(timer);
-        };
-    };
-    const releaseLease = async () => {
-        stopHeartbeat();
-        if (requestId) {
-            await runtime.persistence.releaseRequestClaim(requestId);
-        }
-    };
-    const releaseAndAdvance = async (shiftNext) => {
-        await releaseLease();
-        runtime.setActiveRequestSlots(Math.max(0, runtime.getActiveRequestSlots() - 1));
-        const next = shiftNext();
-        void next?.activate();
-    };
-    const maxConcurrentRuns = runtime.concurrencyConfig.maxConcurrentRuns;
-    if (!maxConcurrentRuns) {
-        await beginLease("direct-heartbeat");
-        return async () => {
-            await releaseLease();
-        };
-    }
-    const canActivateImmediately = runtime.getActiveRequestSlots() < maxConcurrentRuns;
-    const useDirectHeartbeatFastPath = canActivateImmediately && maxConcurrentRuns > 1;
-    if (canActivateImmediately) {
-        runtime.setActiveRequestSlots(runtime.getActiveRequestSlots() + 1);
-        if (sessionId && requestId && !useDirectHeartbeatFastPath) {
-            await runtime.persistence.enqueueRequest({ sessionId, requestId, priority });
-        }
-        await beginLease(useDirectHeartbeatFastPath ? "direct-heartbeat" : "queue-claim");
-        let released = false;
-        return async () => {
-            if (released) {
-                return;
-            }
-            released = true;
-            await releaseAndAdvance(() => shiftNextPendingRequestSlot(runtime.pendingRequestSlots));
-        };
-    }
-    const activateQueuedRequest = async () => {
-        const currentRequest = requestId ? await runtime.persistence.getRequest(requestId) : null;
-        if (currentRequest?.state === "cancelled") {
-            return "abort";
-        }
-        runtime.setActiveRequestSlots(runtime.getActiveRequestSlots() + 1);
-        if (sessionId && requestId) {
-            await runtime.emit(sessionId, requestId, 4, "request.dequeued", {
-                queuePosition: 0,
-                activeRequestCount: runtime.getActiveRequestSlots(),
-                maxConcurrentRuns,
-                priority,
-            });
-            await runtime.setRequestStateAndEmit(sessionId, requestId, 5, activeState, {
-                previousState: "queued",
-            });
-            await beginLease("queue-claim");
-        }
-        return "activate";
-    };
-    if (sessionId && requestId) {
-        await runtime.persistence.enqueueRequest({ sessionId, requestId, priority });
-        const slotAcquisition = new Promise((resolve, reject) => {
-            const displacedEntries = runtime.enqueuePendingRequestSlot({
-                sessionId,
-                requestId,
-                priority,
-                activate: async () => {
-                    try {
-                        resolve(await activateQueuedRequest());
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                },
-                abort: () => resolve("abort"),
-            });
-            void Promise.all(displacedEntries.map((candidate) => runtime.emit(candidate.sessionId, candidate.requestId, 3, "request.queued", {
-                queuePosition: candidate.queuePosition,
-                activeRequestCount: runtime.getActiveRequestSlots(),
-                maxConcurrentRuns,
-                priority: candidate.priority,
-            })));
-        });
-        const queuePosition = runtime.pendingRequestSlots.findIndex((entry) => entry.requestId === requestId) + 1;
-        await runtime.setRequestStateAndEmit(sessionId, requestId, 2, "queued", {
-            previousState: activeState,
-        });
-        await runtime.emit(sessionId, requestId, 3, "request.queued", {
-            queuePosition,
-            activeRequestCount: runtime.getActiveRequestSlots(),
-            maxConcurrentRuns,
-            priority,
-        });
-        const slotAcquisitionResult = await slotAcquisition;
-        if (slotAcquisitionResult === "abort") {
-            return async () => undefined;
-        }
-        let released = false;
-        return async () => {
-            if (released) {
-                return;
-            }
-            released = true;
-            await releaseAndAdvance(() => runtime.pendingRequestSlots.shift());
-        };
-    }
-    let released = false;
-    return async () => {
-        if (released) {
-            return;
-        }
-        released = true;
-        await releaseAndAdvance(() => shiftNextPendingRequestSlot(runtime.pendingRequestSlots));
-    };
-}
+import{shiftNextPendingRequestSlot as p}from"./run-queue.js";async function C(e,l={}){const{sessionId:s,requestId:t}=l,w=l.activeState??"running",o=l.priority??0;let S=()=>{};const q=async a=>{if(!s||!t)return;const c=new Date().toISOString(),R=new Date(Date.now()+e.concurrencyConfig.leaseMs).toISOString();if(a==="queue-claim"?await e.persistence.claimQueuedRequest({sessionId:s,requestId:t,workerId:e.workerId,claimedAt:c,leaseExpiresAt:R}):await e.persistence.renewRequestLease({requestId:t,workerId:e.workerId,heartbeatAt:c,leaseExpiresAt:R}),e.concurrencyConfig.heartbeatIntervalMs<=0)return;const r=setInterval(()=>{e.persistence.renewRequestLease({requestId:t,workerId:e.workerId,heartbeatAt:new Date().toISOString(),leaseExpiresAt:new Date(Date.now()+e.concurrencyConfig.leaseMs).toISOString()})},e.concurrencyConfig.heartbeatIntervalMs);r.unref?.(),S=()=>{clearInterval(r)}},f=async()=>{S(),t&&await e.persistence.releaseRequestClaim(t)},d=async a=>{await f(),e.setActiveRequestSlots(Math.max(0,e.getActiveRequestSlots()-1)),a()?.activate()},i=e.concurrencyConfig.maxConcurrentRuns;if(!i)return await q("direct-heartbeat"),async()=>{await f()};const v=e.getActiveRequestSlots()<i,g=v&&i>1;if(v){e.setActiveRequestSlots(e.getActiveRequestSlots()+1),s&&t&&!g&&await e.persistence.enqueueRequest({sessionId:s,requestId:t,priority:o}),await q(g?"direct-heartbeat":"queue-claim");let a=!1;return async()=>{a||(a=!0,await d(()=>p(e.pendingRequestSlots)))}}const y=async()=>(t?await e.persistence.getRequest(t):null)?.state==="cancelled"?"abort":(e.setActiveRequestSlots(e.getActiveRequestSlots()+1),s&&t&&(await e.emit(s,t,4,"request.dequeued",{queuePosition:0,activeRequestCount:e.getActiveRequestSlots(),maxConcurrentRuns:i,priority:o}),await e.setRequestStateAndEmit(s,t,5,w,{previousState:"queued"}),await q("queue-claim")),"activate");if(s&&t){await e.persistence.enqueueRequest({sessionId:s,requestId:t,priority:o});const a=new Promise((u,I)=>{const b=e.enqueuePendingRequestSlot({sessionId:s,requestId:t,priority:o,activate:async()=>{try{u(await y())}catch(n){I(n)}},abort:()=>u("abort")});Promise.all(b.map(n=>e.emit(n.sessionId,n.requestId,3,"request.queued",{queuePosition:n.queuePosition,activeRequestCount:e.getActiveRequestSlots(),maxConcurrentRuns:i,priority:n.priority})))}),c=e.pendingRequestSlots.findIndex(u=>u.requestId===t)+1;if(await e.setRequestStateAndEmit(s,t,2,"queued",{previousState:w}),await e.emit(s,t,3,"request.queued",{queuePosition:c,activeRequestCount:e.getActiveRequestSlots(),maxConcurrentRuns:i,priority:o}),await a==="abort")return async()=>{};let r=!1;return async()=>{r||(r=!0,await d(()=>e.pendingRequestSlots.shift()))}}let A=!1;return async()=>{A||(A=!0,await d(()=>p(e.pendingRequestSlots)))}}export{C as acquireRequestSlot};

package/dist/runtime/harness/run/session-records.js

@@ -1,97 +1 @@
-import { isTerminalRequestState, toInspectableApprovalRecord } from "./helpers.js";
-import { projectRuntimeTimeline } from "../events/timeline.js";
-function selectLatestPendingApproval(approvals) {
-    return approvals
-        .filter((approval) => approval.status === "pending")
-        .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
-}
-export async function buildRequestInspectionRecord(persistence, request) {
-    const inspection = await persistence.getRequestInspection(request.sessionId, request.requestId);
-    const runtimeEvents = await persistence.listRequestEvents(request.sessionId, request.requestId);
-    return {
-        requestId: request.requestId,
-        sessionId: request.sessionId,
-        agentId: request.agentId,
-        parentRequestId: request.parentRequestId,
-        executionMode: request.executionMode,
-        adapterKind: request.adapterKind,
-        createdAt: request.createdAt,
-        updatedAt: request.updatedAt,
-        state: request.state,
-        checkpointRef: request.checkpointRef,
-        resumable: request.resumable,
-        startedAt: request.startedAt,
-        endedAt: request.endedAt,
-        lastActivityAt: request.lastActivityAt,
-        currentAgentId: request.currentAgentId,
-        delegationChain: request.delegationChain,
-        runtimeSnapshot: request.runtimeSnapshot,
-        traceItems: inspection.traceItems,
-        runtimeTimeline: projectRuntimeTimeline(runtimeEvents, {
-            sessionId: request.sessionId,
-            requestId: request.requestId,
-        }),
-    };
-}
-export async function buildSessionInspectionRecord(input, sessionId) {
-    const [sessionSummary, meta, messages, requestSummaries] = await Promise.all([
-        input.getSession(sessionId),
-        input.persistence.getSessionMeta(sessionId),
-        input.persistence.listSessionMessages(sessionId, 200),
-        input.persistence.listSessionRequests(sessionId),
-    ]);
-    if (!sessionSummary || !meta) {
-        return null;
-    }
-    const latestRequestId = sessionSummary.latestRequestId;
-    const requests = await Promise.all(requestSummaries.map((request) => buildRequestInspectionRecord(input.persistence, request)));
-    const latestApprovals = await input.persistence.getRequestApprovals(sessionId, latestRequestId);
-    const pendingApproval = selectLatestPendingApproval(latestApprovals);
-    return {
-        sessionId,
-        entryAgentId: meta.entryAgentId,
-        currentAgentId: sessionSummary.currentAgentId,
-        currentState: sessionSummary.status,
-        latestRequestId,
-        createdAt: meta.createdAt,
-        updatedAt: sessionSummary.updatedAt,
-        messages,
-        requests,
-        pendingDecision: pendingApproval
-            ? {
-                approvalId: pendingApproval.approvalId,
-                pendingActionId: pendingApproval.pendingActionId,
-                toolName: pendingApproval.toolName,
-                allowedDecisions: pendingApproval.allowedDecisions,
-                requestedAt: pendingApproval.requestedAt,
-            }
-            : undefined,
-    };
-}
-export async function listPublicApprovals(input, filter) {
-    const approvals = await input.persistence.listApprovals({
-        status: filter?.status,
-        sessionId: filter?.sessionId ?? filter?.legacySessionId,
-        requestId: filter?.requestId ?? filter?.legacyRunId,
-    });
-    return approvals.map((approval) => toInspectableApprovalRecord(approval));
-}
-export async function getPublicApproval(input, approvalId) {
-    const approval = await input.persistence.getApproval(approvalId);
-    return approval ? toInspectableApprovalRecord(approval) : null;
-}
-export async function deleteSessionRecord(input, sessionId) {
-    const session = await input.getSession(sessionId);
-    if (!session) {
-        return false;
-    }
-    const activeRequest = session.requests.find((request) => !isTerminalRequestState(request.state));
-    if (activeRequest) {
-        throw new Error(`Cannot delete session ${sessionId} while request ${activeRequest.requestId} is ${activeRequest.state}`);
-    }
-    const deleted = await input.deleteSession(sessionId);
-    if (deleted) {
-        await input.deleteSessionCheckpoints(sessionId);
-    }
-    return deleted;
-}
+import{isTerminalRequestState as u,toInspectableApprovalRecord as d}from"./helpers.js";import{projectRuntimeTimeline as A}from"../events/timeline.js";function I(t){return t.filter(e=>e.status==="pending").sort((e,s)=>s.requestedAt.localeCompare(e.requestedAt))[0]}async function m(t,e){const s=await t.getRequestInspection(e.sessionId,e.requestId),n=await t.listRequestEvents(e.sessionId,e.requestId);return{requestId:e.requestId,sessionId:e.sessionId,agentId:e.agentId,parentRequestId:e.parentRequestId,executionMode:e.executionMode,adapterKind:e.adapterKind,createdAt:e.createdAt,updatedAt:e.updatedAt,state:e.state,checkpointRef:e.checkpointRef,resumable:e.resumable,startedAt:e.startedAt,endedAt:e.endedAt,lastActivityAt:e.lastActivityAt,currentAgentId:e.currentAgentId,delegationChain:e.delegationChain,runtimeSnapshot:e.runtimeSnapshot,traceItems:s.traceItems,runtimeTimeline:A(n,{sessionId:e.sessionId,requestId:e.requestId})}}async function R(t,e){const[s,n,o,i]=await Promise.all([t.getSession(e),t.persistence.getSessionMeta(e),t.persistence.listSessionMessages(e,200),t.persistence.listSessionRequests(e)]);if(!s||!n)return null;const r=s.latestRequestId,c=await Promise.all(i.map(l=>m(t.persistence,l))),p=await t.persistence.getRequestApprovals(e,r),a=I(p);return{sessionId:e,entryAgentId:n.entryAgentId,currentAgentId:s.currentAgentId,currentState:s.status,latestRequestId:r,createdAt:n.createdAt,updatedAt:s.updatedAt,messages:o,requests:c,pendingDecision:a?{approvalId:a.approvalId,pendingActionId:a.pendingActionId,toolName:a.toolName,allowedDecisions:a.allowedDecisions,requestedAt:a.requestedAt}:void 0}}async function S(t,e){return(await t.persistence.listApprovals({status:e?.status,sessionId:e?.sessionId??e?.legacySessionId,requestId:e?.requestId??e?.legacyRunId})).map(n=>d(n))}async function w(t,e){const s=await t.persistence.getApproval(e);return s?d(s):null}async function f(t,e){const s=await t.getSession(e);if(!s)return!1;const n=s.requests.find(i=>!u(i.state));if(n)throw new Error(`Cannot delete session ${e} while request ${n.requestId} is ${n.state}`);const o=await t.deleteSession(e);return o&&await t.deleteSessionCheckpoints(e),o}export{m as buildRequestInspectionRecord,R as buildSessionInspectionRecord,f as deleteSessionRecord,w as getPublicApproval,S as listPublicApprovals};

package/dist/runtime/harness/run/start-run.js

@@ -1,120 +1 @@
-import { AUTO_AGENT_ID } from "../../../contracts/types.js";
-import { createPersistentId } from "../../../utils/id.js";
-import { normalizeMessageContent } from "../../../utils/message-content.js";
-import { buildPersistedRequestInput, normalizeRequestPriority } from "./helpers.js";
-import { getRequiredWorkspaceBinding } from "../bindings.js";
-import { getBindingAdapterKind, getBindingRuntimeExecutionMode } from "../../support/compiled-binding.js";
-import { buildRequestRuntimeSnapshot } from "./inspection.js";
-async function appendUserMessage(runtime, sessionId, message) {
-    await runtime.persistence.appendSessionMessage?.(sessionId, message);
-}
-async function saveRequestInput(runtime, sessionId, requestId, requestInput) {
-    await runtime.persistence.saveRequestInput?.(sessionId, requestId, requestInput);
-}
-async function createSessionRecord(runtime, sessionId, input) {
-    await runtime.persistence.createSession({
-        sessionId,
-        agentId: input.agentId,
-        requestId: input.requestId,
-        status: input.status,
-        createdAt: input.createdAt,
-    });
-}
-async function createRequestRecord(runtime, sessionId, requestId, input) {
-    await runtime.persistence.createRequest({
-        sessionId,
-        requestId,
-        ...input,
-    });
-}
-export async function ensureSessionStarted(runtime, input) {
-    const { selectedAgentId, binding, message, requestInput, existingSessionId } = input;
-    const sessionId = existingSessionId ?? createPersistentId();
-    const requestId = createPersistentId();
-    const createdAt = new Date().toISOString();
-    const isNewSession = !existingSessionId;
-    const startedAt = createdAt;
-    const currentAgentId = selectedAgentId;
-    const delegationChain = [selectedAgentId];
-    const runtimeSnapshot = buildRequestRuntimeSnapshot(binding, { requestId });
-    const userMessage = {
-        role: "user",
-        content: normalizeMessageContent(message),
-        requestId,
-        createdAt,
-    };
-    if (typeof runtime.persistence.bootstrapRequest === "function") {
-        await runtime.persistence.bootstrapRequest({
-            sessionId,
-            agentId: binding.agent.id,
-            requestId,
-            status: "running",
-            createdAt,
-            executionMode: getBindingRuntimeExecutionMode(binding),
-            adapterKind: getBindingAdapterKind(binding),
-            userMessage,
-            requestInput,
-            createSession: isNewSession,
-            startedAt,
-            currentAgentId,
-            delegationChain,
-            runtimeSnapshot,
-        });
-    }
-    else {
-        if (isNewSession) {
-            await createSessionRecord(runtime, sessionId, {
-                agentId: selectedAgentId,
-                requestId,
-                status: "running",
-                createdAt,
-            });
-        }
-        await Promise.all([
-            appendUserMessage(runtime, sessionId, userMessage),
-            createRequestRecord(runtime, sessionId, requestId, {
-                agentId: binding.agent.id,
-                executionMode: getBindingRuntimeExecutionMode(binding),
-                adapterKind: getBindingAdapterKind(binding),
-                createdAt,
-                startedAt,
-                currentAgentId,
-                delegationChain,
-                runtimeSnapshot,
-            }),
-            saveRequestInput(runtime, sessionId, requestId, requestInput),
-        ]);
-    }
-    return { sessionId, requestId, createdAt, isNewSession };
-}
-export async function prepareRunStart(runtime, input) {
-    const { options, invocation, requestCreatedPayload } = input;
-    const selectedAgentId = await runtime.resolveSelectedAgentId(options.input, options.agentId, options.sessionId);
-    const binding = getRequiredWorkspaceBinding(runtime.workspace, selectedAgentId);
-    const policyDecision = runtime.policyEngine.evaluate(binding);
-    if (!policyDecision.allowed) {
-        throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
-    }
-    const priority = normalizeRequestPriority(options.priority);
-    const requestInput = buildPersistedRequestInput(options.input, invocation, priority);
-    const { sessionId, requestId, isNewSession } = await ensureSessionStarted(runtime, {
-        selectedAgentId,
-        binding,
-        message: options.input,
-        requestInput,
-        existingSessionId: options.sessionId,
-    });
-    return {
-        binding,
-        selectedAgentId,
-        priority,
-        sessionId,
-        requestId,
-        isNewSession,
-        requestCreatedEventPromise: runtime.emitRequestCreated(sessionId, requestId, requestCreatedPayload(binding, selectedAgentId)),
-        releaseRequestSlotPromise: runtime.acquireRequestSlot(sessionId, requestId, "running", priority),
-    };
-}
-export function defaultRequestedAgentId(agentId) {
-    return agentId ?? AUTO_AGENT_ID;
-}
+import{AUTO_AGENT_ID as w}from"../../../contracts/types.js";import{createPersistentId as f}from"../../../utils/id.js";import{normalizeMessageContent as m}from"../../../utils/message-content.js";import{buildPersistedRequestInput as y,normalizeRequestPriority as A}from"./helpers.js";import{getRequiredWorkspaceBinding as x}from"../bindings.js";import{getBindingAdapterKind as R,getBindingRuntimeExecutionMode as S}from"../../support/compiled-binding.js";import{buildRequestRuntimeSnapshot as P}from"./inspection.js";async function b(e,n,t){await e.persistence.appendSessionMessage?.(n,t)}async function v(e,n,t,s){await e.persistence.saveRequestInput?.(n,t,s)}async function M(e,n,t){await e.persistence.createSession({sessionId:n,agentId:t.agentId,requestId:t.requestId,status:t.status,createdAt:t.createdAt})}async function C(e,n,t,s){await e.persistence.createRequest({sessionId:n,requestId:t,...s})}async function E(e,n){const{selectedAgentId:t,binding:s,message:g,requestInput:a,existingSessionId:c}=n,i=c??f(),o=f(),r=new Date().toISOString(),d=!c,u=r,p=t,I=[t],l=P(s,{requestId:o}),q={role:"user",content:m(g),requestId:o,createdAt:r};return typeof e.persistence.bootstrapRequest=="function"?await e.persistence.bootstrapRequest({sessionId:i,agentId:s.agent.id,requestId:o,status:"running",createdAt:r,executionMode:S(s),adapterKind:R(s),userMessage:q,requestInput:a,createSession:d,startedAt:u,currentAgentId:p,delegationChain:I,runtimeSnapshot:l}):(d&&await M(e,i,{agentId:t,requestId:o,status:"running",createdAt:r}),await Promise.all([b(e,i,q),C(e,i,o,{agentId:s.agent.id,executionMode:S(s),adapterKind:R(s),createdAt:r,startedAt:u,currentAgentId:p,delegationChain:I,runtimeSnapshot:l}),v(e,i,o,a)])),{sessionId:i,requestId:o,createdAt:r,isNewSession:d}}async function O(e,n){const{options:t,invocation:s,requestCreatedPayload:g}=n,a=await e.resolveSelectedAgentId(t.input,t.agentId,t.sessionId),c=x(e.workspace,a),i=e.policyEngine.evaluate(c);if(!i.allowed)throw new Error(`Policy evaluation blocked agent ${a}: ${i.reasons.join(", ")}`);const o=A(t.priority),r=y(t.input,s,o),{sessionId:d,requestId:u,isNewSession:p}=await E(e,{selectedAgentId:a,binding:c,message:t.input,requestInput:r,existingSessionId:t.sessionId});return{binding:c,selectedAgentId:a,priority:o,sessionId:d,requestId:u,isNewSession:p,requestCreatedEventPromise:e.emitRequestCreated(d,u,g(c,a)),releaseRequestSlotPromise:e.acquireRequestSlot(d,u,"running",o)}}function T(e){return e??w}export{T as defaultRequestedAgentId,E as ensureSessionStarted,O as prepareRunStart};

package/dist/runtime/harness/run/startup-runtime.js

@@ -1,69 +1 @@
-import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./recovery.js";
-import { traceStartupStage } from "../../startup-tracing.js";
-export async function initializeHarnessRuntime(input) {
-    await traceStartupStage("runtime.initialize.persistence", () => input.persistence.initialize());
-    if (input.healthMonitor) {
-        const healthMonitorStartTask = traceStartupStage("runtime.initialize.healthMonitor", () => input.healthMonitor.start());
-        if (input.scheduleBackgroundTask) {
-            input.scheduleBackgroundTask(healthMonitorStartTask);
-        }
-        else {
-            await healthMonitorStartTask;
-        }
-    }
-}
-export async function recoverStartupRequests(input) {
-    if (!input.recoveryConfig.enabled) {
-        return;
-    }
-    await input.reclaimExpiredClaimedRequests();
-    const sessions = await input.persistence.listSessions();
-    if (sessions.length === 0) {
-        return;
-    }
-    const context = input.createStartupRecoveryContext();
-    for (const session of sessions) {
-        if (await recoverQueuedStartupRun(context, session)) {
-            continue;
-        }
-        if (await recoverRunningStartupRun(context, session)) {
-            continue;
-        }
-        await recoverResumingStartupRun(context, session);
-    }
-}
-export async function reclaimExpiredClaimedRequests(input, nowIso = new Date().toISOString()) {
-    const expiredRuns = await input.persistence.listExpiredClaimedRequests(nowIso);
-    if (expiredRuns.length === 0) {
-        return;
-    }
-    const activeRequestCount = input.getActiveRequestSlots();
-    const maxConcurrentRuns = input.concurrencyConfig.maxConcurrentRuns;
-    for (const [index, claimedRequest] of expiredRuns.entries()) {
-        const sessionId = claimedRequest.sessionId;
-        const requestId = claimedRequest.requestId;
-        await input.persistence.releaseRequestClaim(requestId);
-        await input.setRequestStateAndEmit(sessionId, requestId, 100, "queued", {
-            previousState: "claimed",
-        });
-        await input.emit(sessionId, requestId, 101, "request.queued", {
-            queuePosition: activeRequestCount + index + 1,
-            activeRequestCount,
-            ...(maxConcurrentRuns !== undefined ? { maxConcurrentRuns } : {}),
-            priority: claimedRequest.priority,
-            recoveryKind: "startup-claim-recovery",
-        });
-    }
-}
-export async function isStaleRunningRequest(input, session, nowMs = Date.now()) {
-    const control = await input.persistence.getRequestControl(session.latestRequestId);
-    const heartbeatAt = control?.heartbeatAt;
-    if (!heartbeatAt) {
-        return true;
-    }
-    const heartbeatAtMs = Date.parse(heartbeatAt);
-    if (!Number.isFinite(heartbeatAtMs)) {
-        return true;
-    }
-    return nowMs - heartbeatAtMs >= input.concurrencyConfig.heartbeatTimeoutMs;
-}
+import{recoverQueuedStartupRun as l,recoverResumingStartupRun as d,recoverRunningStartupRun as f}from"./recovery.js";import{traceStartupStage as u}from"../../startup-tracing.js";async function q(e){if(await u("runtime.initialize.persistence",()=>e.persistence.initialize()),e.healthMonitor){const t=u("runtime.initialize.healthMonitor",()=>e.healthMonitor.start());e.scheduleBackgroundTask?e.scheduleBackgroundTask(t):await t}}async function h(e){if(!e.recoveryConfig.enabled)return;await e.reclaimExpiredClaimedRequests();const t=await e.persistence.listSessions();if(t.length===0)return;const r=e.createStartupRecoveryContext();for(const i of t)await l(r,i)||await f(r,i)||await d(r,i)}async function S(e,t=new Date().toISOString()){const r=await e.persistence.listExpiredClaimedRequests(t);if(r.length===0)return;const i=e.getActiveRequestSlots(),s=e.concurrencyConfig.maxConcurrentRuns;for(const[n,a]of r.entries()){const c=a.sessionId,o=a.requestId;await e.persistence.releaseRequestClaim(o),await e.setRequestStateAndEmit(c,o,100,"queued",{previousState:"claimed"}),await e.emit(c,o,101,"request.queued",{queuePosition:i+n+1,activeRequestCount:i,...s!==void 0?{maxConcurrentRuns:s}:{},priority:a.priority,recoveryKind:"startup-claim-recovery"})}}async function g(e,t,r=Date.now()){const s=(await e.persistence.getRequestControl(t.latestRequestId))?.heartbeatAt;if(!s)return!0;const n=Date.parse(s);return Number.isFinite(n)?r-n>=e.concurrencyConfig.heartbeatTimeoutMs:!0}export{q as initializeHarnessRuntime,g as isStaleRunningRequest,S as reclaimExpiredClaimedRequests,h as recoverStartupRequests};