@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/runtime/harness/run/recovery.js

@@ -1,162 +1 @@
-import { normalizeRequestPriority } from "./helpers.js";
-async function setRequestState(persistence, sessionId, requestId, state, checkpointRef) {
-    await persistence.setRequestState(sessionId, requestId, state, checkpointRef);
-}
-async function failRecovery(context, session, previousState, error, options = {}) {
-    await context.setRequestStateAndEmit(session.sessionId, session.latestRequestId, 100, "failed", {
-        previousState,
-        error,
-    });
-    if (options.releaseRequestClaim) {
-        await context.persistence.releaseRequestClaim(session.latestRequestId);
-    }
-    return true;
-}
-async function resolveRecoveryBinding(context, session) {
-    const runMeta = await context.persistence.getRequestMeta(session.sessionId, session.latestRequestId);
-    const binding = context.getBinding(runMeta.agentId);
-    if (!binding) {
-        return null;
-    }
-    return {
-        binding,
-        agentId: runMeta.agentId,
-    };
-}
-async function executeRecoveredRequest(context, input) {
-    const { session, binding, agentId, request, previousState, emitResumeEvent } = input;
-    const releaseRequestSlot = await context.acquireRequestSlot(session.sessionId, session.latestRequestId, "running", normalizeRequestPriority(request.priority));
-    try {
-        if (emitResumeEvent) {
-            await context.emit(session.sessionId, session.latestRequestId, emitResumeEvent.sequence, emitResumeEvent.eventType, emitResumeEvent.payload);
-        }
-        await context.executeQueuedRequest(binding, request.input, session.sessionId, session.latestRequestId, agentId, {
-            context: request.invocation?.context,
-            state: request.invocation?.inputs,
-            files: request.invocation?.attachments,
-            previousState,
-            stateSequence: 103,
-            approvalSequence: 104,
-        });
-    }
-    finally {
-        await releaseRequestSlot();
-    }
-    return true;
-}
-async function failResumingRecovery(context, session, checkpointRef, error) {
-    await setRequestState(context.persistence, session.sessionId, session.latestRequestId, "failed", checkpointRef);
-    await context.persistence.clearRequestRecoveryIntent(session.sessionId, session.latestRequestId);
-    await context.emit(session.sessionId, session.latestRequestId, 101, "request.state.changed", {
-        previousState: "resuming",
-        state: "failed",
-        checkpointRef,
-        ...(error ? { error } : {}),
-    });
-    return true;
-}
-export async function recoverQueuedStartupRun(context, session) {
-    if (session.status !== "queued") {
-        return false;
-    }
-    const resolved = await resolveRecoveryBinding(context, session);
-    if (!resolved) {
-        return true;
-    }
-    const request = await context.persistence.getRequestInput(session.sessionId, session.latestRequestId);
-    if (!request) {
-        return failRecovery(context, session, "queued", "missing persisted request input for queued request recovery");
-    }
-    return executeRecoveredRequest(context, {
-        session,
-        binding: resolved.binding,
-        agentId: resolved.agentId,
-        request,
-        previousState: "queued",
-    });
-}
-export async function recoverRunningStartupRun(context, session) {
-    if (session.status !== "running") {
-        return false;
-    }
-    const isStale = await context.isStaleRunningRequest(session);
-    if (!isStale) {
-        return true;
-    }
-    const resolved = await resolveRecoveryBinding(context, session);
-    if (!resolved) {
-        return true;
-    }
-    if (!context.supportsRunningReplay(resolved.binding)) {
-        return failRecovery(context, session, "running", "stale running request cannot be replayed safely", {
-            releaseRequestClaim: true,
-        });
-    }
-    const request = await context.persistence.getRequestInput(session.sessionId, session.latestRequestId);
-    if (!request) {
-        return failRecovery(context, session, "running", "missing persisted request input for stale running request recovery", {
-            releaseRequestClaim: true,
-        });
-    }
-    return executeRecoveredRequest(context, {
-        session,
-        binding: resolved.binding,
-        agentId: resolved.agentId,
-        request,
-        previousState: "running",
-        emitResumeEvent: {
-            sequence: 100,
-            eventType: "request.resumed",
-            payload: {
-                resumeKind: "startup-running-recovery",
-                state: "running",
-            },
-        },
-    });
-}
-export async function recoverResumingStartupRun(context, session) {
-    if (session.status !== "resuming" || !context.recoveryConfig.resumeResumingRequestsOnStartup) {
-        return false;
-    }
-    const binding = context.getBinding(session.agentId);
-    if (!binding) {
-        return true;
-    }
-    const recoveryIntent = await context.persistence.getRequestRecoveryIntent(session.sessionId, session.latestRequestId);
-    if (!recoveryIntent || recoveryIntent.kind !== "approval-decision") {
-        return true;
-    }
-    if (recoveryIntent.attempts >= context.recoveryConfig.maxRecoveryAttempts) {
-        return failResumingRecovery(context, session, recoveryIntent.checkpointRef, "recovery attempts exhausted");
-    }
-    await context.persistence.saveRequestRecoveryIntent(session.sessionId, session.latestRequestId, {
-        ...recoveryIntent,
-        attempts: recoveryIntent.attempts + 1,
-    });
-    await context.emit(session.sessionId, session.latestRequestId, 100, "request.resumed", {
-        resumeKind: "startup-recovery",
-        checkpointRef: recoveryIntent.checkpointRef,
-        state: "resuming",
-    });
-    const history = await context.persistence.listSessionMessages(session.sessionId);
-    const priorHistory = history.filter((message) => message.requestId !== session.latestRequestId);
-    const requestInput = await context.loadRequestInput(session.sessionId, session.latestRequestId);
-    const startedAt = Date.now();
-    try {
-        const actual = await context.runtimeAdapter.invoke(binding, "", session.sessionId, session.latestRequestId, recoveryIntent.resumePayload, priorHistory);
-        context.recordLlmSuccess(startedAt);
-        await context.persistence.clearRequestRecoveryIntent(session.sessionId, session.latestRequestId);
-        await context.finalizeContinuedRequest(binding, session.sessionId, session.latestRequestId, requestInput, actual, {
-            previousState: "resuming",
-            stateSequence: 101,
-            approvalSequence: 102,
-        });
-    }
-    catch (error) {
-        context.recordLlmFailure(startedAt);
-        if (recoveryIntent.attempts + 1 >= context.recoveryConfig.maxRecoveryAttempts) {
-            await failResumingRecovery(context, session, recoveryIntent.checkpointRef, error instanceof Error ? error.message : String(error));
-        }
-    }
-    return true;
-}
+import{normalizeRequestPriority as p}from"./helpers.js";async function I(t,e,a,r,u){await t.setRequestState(e,a,r,u)}async function l(t,e,a,r,u={}){return await t.setRequestStateAndEmit(e.sessionId,e.latestRequestId,100,"failed",{previousState:a,error:r}),u.releaseRequestClaim&&await t.persistence.releaseRequestClaim(e.latestRequestId),!0}async function c(t,e){const a=await t.persistence.getRequestMeta(e.sessionId,e.latestRequestId),r=t.getBinding(a.agentId);return r?{binding:r,agentId:a.agentId}:null}async function R(t,e){const{session:a,binding:r,agentId:u,request:i,previousState:d,emitResumeEvent:s}=e,n=await t.acquireRequestSlot(a.sessionId,a.latestRequestId,"running",p(i.priority));try{s&&await t.emit(a.sessionId,a.latestRequestId,s.sequence,s.eventType,s.payload),await t.executeQueuedRequest(r,i.input,a.sessionId,a.latestRequestId,u,{context:i.invocation?.context,state:i.invocation?.inputs,files:i.invocation?.attachments,previousState:d,stateSequence:103,approvalSequence:104})}finally{await n()}return!0}async function q(t,e,a,r){return await I(t.persistence,e.sessionId,e.latestRequestId,"failed",a),await t.persistence.clearRequestRecoveryIntent(e.sessionId,e.latestRequestId),await t.emit(e.sessionId,e.latestRequestId,101,"request.state.changed",{previousState:"resuming",state:"failed",checkpointRef:a,...r?{error:r}:{}}),!0}async function o(t,e){if(e.status!=="queued")return!1;const a=await c(t,e);if(!a)return!0;const r=await t.persistence.getRequestInput(e.sessionId,e.latestRequestId);return r?R(t,{session:e,binding:a.binding,agentId:a.agentId,request:r,previousState:"queued"}):l(t,e,"queued","missing persisted request input for queued request recovery")}async function f(t,e){if(e.status!=="running")return!1;if(!await t.isStaleRunningRequest(e))return!0;const r=await c(t,e);if(!r)return!0;if(!t.supportsRunningReplay(r.binding))return l(t,e,"running","stale running request cannot be replayed safely",{releaseRequestClaim:!0});const u=await t.persistence.getRequestInput(e.sessionId,e.latestRequestId);return u?R(t,{session:e,binding:r.binding,agentId:r.agentId,request:u,previousState:"running",emitResumeEvent:{sequence:100,eventType:"request.resumed",payload:{resumeKind:"startup-running-recovery",state:"running"}}}):l(t,e,"running","missing persisted request input for stale running request recovery",{releaseRequestClaim:!0})}async function m(t,e){if(e.status!=="resuming"||!t.recoveryConfig.resumeResumingRequestsOnStartup)return!1;const a=t.getBinding(e.agentId);if(!a)return!0;const r=await t.persistence.getRequestRecoveryIntent(e.sessionId,e.latestRequestId);if(!r||r.kind!=="approval-decision")return!0;if(r.attempts>=t.recoveryConfig.maxRecoveryAttempts)return q(t,e,r.checkpointRef,"recovery attempts exhausted");await t.persistence.saveRequestRecoveryIntent(e.sessionId,e.latestRequestId,{...r,attempts:r.attempts+1}),await t.emit(e.sessionId,e.latestRequestId,100,"request.resumed",{resumeKind:"startup-recovery",checkpointRef:r.checkpointRef,state:"resuming"});const i=(await t.persistence.listSessionMessages(e.sessionId)).filter(n=>n.requestId!==e.latestRequestId),d=await t.loadRequestInput(e.sessionId,e.latestRequestId),s=Date.now();try{const n=await t.runtimeAdapter.invoke(a,"",e.sessionId,e.latestRequestId,r.resumePayload,i);t.recordLlmSuccess(s),await t.persistence.clearRequestRecoveryIntent(e.sessionId,e.latestRequestId),await t.finalizeContinuedRequest(a,e.sessionId,e.latestRequestId,d,n,{previousState:"resuming",stateSequence:101,approvalSequence:102})}catch(n){t.recordLlmFailure(s),r.attempts+1>=t.recoveryConfig.maxRecoveryAttempts&&await q(t,e,r.checkpointRef,n instanceof Error?n.message:String(n))}return!0}export{o as recoverQueuedStartupRun,m as recoverResumingStartupRun,f as recoverRunningStartupRun};

package/dist/runtime/harness/run/resources.js

@@ -1,60 +1 @@
-import { createCheckpointerForConfig, createStoreForConfig } from "../../support/runtime-factories.js";
-import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "../../support/embedding-models.js";
-import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "../../support/vector-stores.js";
-import { resolveRuntimeCheckpointerPath } from "../../layout/runtime-layout.js";
-export function resolveStoreFromConfig(stores, storeConfig, runtimeRoot) {
-    const cacheKey = storeConfig ? `${runtimeRoot}:${JSON.stringify(storeConfig)}` : undefined;
-    if (!storeConfig || !cacheKey) {
-        return undefined;
-    }
-    const existing = stores.get(cacheKey);
-    if (existing) {
-        return existing;
-    }
-    const created = createStoreForConfig(storeConfig, runtimeRoot);
-    stores.set(cacheKey, created);
-    return created;
-}
-export function resolveStore(stores, defaultStore, defaultRuntimeRoot, getBindingStoreConfig, binding) {
-    const storeConfig = getBindingStoreConfig(binding);
-    return resolveStoreFromConfig(stores, storeConfig, binding?.harnessRuntime.runtimeRoot ?? defaultRuntimeRoot) ?? defaultStore;
-}
-export async function resolveEmbeddingModel(workspace, embeddingModels, embeddingModelRef, runtimeAdapterOptions) {
-    const compiled = resolveCompiledEmbeddingModelRef(workspace, embeddingModelRef);
-    const existing = embeddingModels.get(compiled.id);
-    if (existing) {
-        return existing;
-    }
-    const resolved = await resolveCompiledEmbeddingModel(compiled, runtimeAdapterOptions.embeddingModelResolver);
-    embeddingModels.set(compiled.id, resolved);
-    return resolved;
-}
-export async function resolveVectorStore(workspace, vectorStores, vectorStoreRef, runtimeAdapterOptions) {
-    const compiled = resolveCompiledVectorStoreRef(workspace, vectorStoreRef);
-    const existing = vectorStores.get(compiled.id);
-    if (existing) {
-        return existing;
-    }
-    const resolved = await resolveCompiledVectorStore(workspace, compiled, {
-        embeddingModelResolver: runtimeAdapterOptions.embeddingModelResolver,
-        vectorStoreResolver: runtimeAdapterOptions.vectorStoreResolver,
-    });
-    vectorStores.set(compiled.id, resolved);
-    return resolved;
-}
-export function resolveCheckpointer(checkpointers, binding) {
-    const key = `${binding.harnessRuntime.runtimeRoot}:${JSON.stringify(binding.harnessRuntime.checkpointer ?? { kind: "SqliteSaver", path: resolveRuntimeCheckpointerPath(binding.harnessRuntime.runtimeRoot, "checkpoints.sqlite") })}`;
-    const existing = checkpointers.get(key);
-    if (existing) {
-        return existing;
-    }
-    const resolvedConfig = binding.harnessRuntime.checkpointer ??
-        { kind: "SqliteSaver", path: resolveRuntimeCheckpointerPath(binding.harnessRuntime.runtimeRoot, "checkpoints.sqlite") };
-    if (typeof resolvedConfig === "boolean") {
-        checkpointers.set(key, resolvedConfig);
-        return resolvedConfig;
-    }
-    const saver = createCheckpointerForConfig(resolvedConfig, binding.harnessRuntime.runtimeRoot);
-    checkpointers.set(key, saver);
-    return saver;
-}
+import{createCheckpointerForConfig as l,createStoreForConfig as m}from"../../support/runtime-factories.js";import{resolveCompiledEmbeddingModel as u,resolveCompiledEmbeddingModelRef as d}from"../../support/embedding-models.js";import{resolveCompiledVectorStore as f,resolveCompiledVectorStoreRef as a}from"../../support/vector-stores.js";import{resolveRuntimeCheckpointerPath as c}from"../../layout/runtime-layout.js";function v(o,e,i){const r=e?`${i}:${JSON.stringify(e)}`:void 0;if(!e||!r)return;const t=o.get(r);if(t)return t;const n=m(e,i);return o.set(r,n),n}function g(o,e,i,r,t){const n=r(t);return v(o,n,t?.harnessRuntime.runtimeRoot??i)??e}async function x(o,e,i,r){const t=d(o,i),n=e.get(t.id);if(n)return n;const s=await u(t,r.embeddingModelResolver);return e.set(t.id,s),s}async function C(o,e,i,r){const t=a(o,i),n=e.get(t.id);if(n)return n;const s=await f(o,t,{embeddingModelResolver:r.embeddingModelResolver,vectorStoreResolver:r.vectorStoreResolver});return e.set(t.id,s),s}function k(o,e){const i=`${e.harnessRuntime.runtimeRoot}:${JSON.stringify(e.harnessRuntime.checkpointer??{kind:"SqliteSaver",path:c(e.harnessRuntime.runtimeRoot,"checkpoints.sqlite")})}`,r=o.get(i);if(r)return r;const t=e.harnessRuntime.checkpointer??{kind:"SqliteSaver",path:c(e.harnessRuntime.runtimeRoot,"checkpoints.sqlite")};if(typeof t=="boolean")return o.set(i,t),t;const n=l(t,e.harnessRuntime.runtimeRoot);return o.set(i,n),n}export{k as resolveCheckpointer,x as resolveEmbeddingModel,g as resolveStore,v as resolveStoreFromConfig,C as resolveVectorStore};

package/dist/runtime/harness/run/resume.js

@@ -1,56 +1 @@
-import { isDeepAgentBinding } from "../../support/compiled-binding.js";
-export async function resolveApprovalRecord(persistence, options, session) {
-    if (options.approvalId) {
-        const approval = await persistence.getApproval(options.approvalId);
-        if (!approval) {
-            throw new Error(`Unknown approval ${options.approvalId}`);
-        }
-        return approval;
-    }
-    const requestId = options.requestId ?? session.latestRequestId;
-    const approvals = await persistence.getRequestApprovals(options.sessionId ?? session.sessionId, requestId);
-    const approval = approvals
-        .filter((candidate) => candidate.status === "pending")
-        .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
-    if (!approval) {
-        throw new Error(`No pending approval for request ${requestId}`);
-    }
-    return approval;
-}
-export function buildResumePayload(binding, approval, options) {
-    if (!isDeepAgentBinding(binding)) {
-        return options.decision === "edit" && options.editedInput
-            ? { decision: "edit", editedInput: options.editedInput }
-            : (options.decision ?? "approve");
-    }
-    const decisionType = options.decision ?? "approve";
-    if (decisionType === "edit" && options.editedInput) {
-        return {
-            decisions: [
-                {
-                    type: "edit",
-                    editedAction: {
-                        name: approval.toolName,
-                        args: options.editedInput,
-                    },
-                },
-            ],
-        };
-    }
-    if (decisionType === "reject") {
-        return {
-            decisions: [
-                {
-                    type: "reject",
-                },
-            ],
-        };
-    }
-    return {
-        decisions: [
-            {
-                type: "approve",
-            },
-        ],
-    };
-}
+import{isDeepAgentBinding as n}from"../../support/compiled-binding.js";async function u(a,r,e){if(r.approvalId){const t=await a.getApproval(r.approvalId);if(!t)throw new Error(`Unknown approval ${r.approvalId}`);return t}const d=r.requestId??e.latestRequestId,i=(await a.getRequestApprovals(r.sessionId??e.sessionId,d)).filter(t=>t.status==="pending").sort((t,p)=>p.requestedAt.localeCompare(t.requestedAt))[0];if(!i)throw new Error(`No pending approval for request ${d}`);return i}function c(a,r,e){if(!n(a))return e.decision==="edit"&&e.editedInput?{decision:"edit",editedInput:e.editedInput}:e.decision??"approve";const d=e.decision??"approve";return d==="edit"&&e.editedInput?{decisions:[{type:"edit",editedAction:{name:r.toolName,args:e.editedInput}}]}:d==="reject"?{decisions:[{type:"reject"}]}:{decisions:[{type:"approve"}]}}export{c as buildResumePayload,u as resolveApprovalRecord};

package/dist/runtime/harness/run/routing.js

@@ -1,48 +1 @@
-import { AUTO_AGENT_ID } from "../../../contracts/types.js";
-import { extractMessageText } from "../../../utils/message-content.js";
-import { matchRoutingRule } from "../../../workspace/support/workspace-ref-utils.js";
-import { getWorkspaceBinding } from "../bindings.js";
-import { inferRoutingBindings } from "../../support/harness-support.js";
-export function getDefaultHostAgentId(workspace, preferredHostAgentId) {
-    const preferredBinding = preferredHostAgentId ? workspace.bindings.get(preferredHostAgentId) : undefined;
-    if (preferredBinding) {
-        return preferredBinding.agent.id;
-    }
-    return inferRoutingBindings(workspace).primaryBinding?.agent.id ?? "agent";
-}
-export function getDefaultRuntimeEntryAgentId(workspace, preferredRuntimeEntryAgentId) {
-    return getDefaultHostAgentId(workspace, preferredRuntimeEntryAgentId);
-}
-export async function resolveSelectedAgentId(options) {
-    const { workspace, input, requestedAgentId, sessionId, preferredHostAgentId, preferredRuntimeEntryAgentId, getSessionSummary, } = options;
-    const preferredEntryAgentId = preferredRuntimeEntryAgentId ?? preferredHostAgentId;
-    if (!requestedAgentId || requestedAgentId === AUTO_AGENT_ID) {
-        if (sessionId) {
-            const session = await getSessionSummary(sessionId);
-            const sessionBinding = session ? workspace.bindings.get(session.agentId) : undefined;
-            if (session?.agentId && sessionBinding) {
-                return session.agentId;
-            }
-        }
-        return getDefaultRuntimeEntryAgentId(workspace, preferredEntryAgentId);
-    }
-    return requestedAgentId;
-}
-export function routeAgentId(options) {
-    const { workspace, input, routingRules, routingDefaultAgentId, sessionId } = options;
-    const rawInput = extractMessageText(input);
-    const configuredRule = routingRules.find((rule) => matchRoutingRule(rawInput, rule, { sessionId }));
-    if (configuredRule) {
-        const configuredBinding = getWorkspaceBinding(workspace, configuredRule.agentId);
-        if (configuredBinding) {
-            return configuredBinding.agent.id;
-        }
-    }
-    const defaultBinding = routingDefaultAgentId
-        ? getWorkspaceBinding(workspace, routingDefaultAgentId)
-        : undefined;
-    if (defaultBinding) {
-        return defaultBinding.agent.id;
-    }
-    return getDefaultRuntimeEntryAgentId(workspace, routingDefaultAgentId);
-}
+import{AUTO_AGENT_ID as p}from"../../../contracts/types.js";import{extractMessageText as m}from"../../../utils/message-content.js";import{matchRoutingRule as I}from"../../../workspace/support/workspace-ref-utils.js";import{getWorkspaceBinding as f}from"../bindings.js";import{inferRoutingBindings as A}from"../../support/harness-support.js";function l(t,n){const r=n?t.bindings.get(n):void 0;return r?r.agent.id:A(t).primaryBinding?.agent.id??"agent"}function a(t,n){return l(t,n)}async function E(t){const{workspace:n,input:r,requestedAgentId:o,sessionId:i,preferredHostAgentId:u,preferredRuntimeEntryAgentId:s,getSessionSummary:d}=t,g=s??u;if(!o||o===p){if(i){const e=await d(i),c=e?n.bindings.get(e.agentId):void 0;if(e?.agentId&&c)return e.agentId}return a(n,g)}return o}function w(t){const{workspace:n,input:r,routingRules:o,routingDefaultAgentId:i,sessionId:u}=t,s=m(r),d=o.find(e=>I(s,e,{sessionId:u}));if(d){const e=f(n,d.agentId);if(e)return e.agent.id}const g=i?f(n,i):void 0;return g?g.agent.id:a(n,i)}export{l as getDefaultHostAgentId,a as getDefaultRuntimeEntryAgentId,E as resolveSelectedAgentId,w as routeAgentId};

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

@@ -1,66 +1 @@
-export async function appendAssistantMessage(persistence, sessionId, requestId, content) {
-    if (!content) {
-        return;
-    }
-    await persistence.appendSessionMessage(sessionId, {
-        role: "assistant",
-        content,
-        requestId,
-        createdAt: new Date().toISOString(),
-    });
-}
-export function checkpointRefForState(sessionId, requestId, state) {
-    return state === "waiting_for_approval" ? `checkpoints/${sessionId}/${requestId}/cp-1` : null;
-}
-export async function expirePendingApprovals(runtime, sessionId, requestId) {
-    const approvals = await runtime.persistence.getRequestApprovals(sessionId, requestId);
-    for (const approval of approvals) {
-        if (approval.status !== "pending") {
-            continue;
-        }
-        await runtime.persistence.resolveApproval(sessionId, requestId, approval.approvalId, "expired");
-        await runtime.emit(sessionId, requestId, 6, "approval.resolved", {
-            approvalId: approval.approvalId,
-            pendingActionId: approval.pendingActionId,
-            decision: "cancel",
-            toolName: approval.toolName,
-        });
-    }
-}
-export async function finalizeCancelledRequest(runtime, sessionId, requestId, previousState, reason) {
-    await expirePendingApprovals(runtime, sessionId, requestId);
-    await runtime.persistence.releaseRequestClaim(requestId);
-    await runtime.persistence.clearRequestCancel(requestId);
-    await runtime.persistence.clearRequestInput(sessionId, requestId);
-    await runtime.setRequestStateAndEmit(sessionId, requestId, 104, "cancelled", {
-        previousState,
-        ...(reason ? { error: reason } : {}),
-    });
-    const requestMeta = await runtime.persistence.getRequestMeta(sessionId, requestId);
-    return {
-        sessionId,
-        requestId,
-        agentId: requestMeta.agentId,
-        state: "cancelled",
-        output: reason ? `cancelled: ${reason}` : "cancelled",
-    };
-}
-export async function finalizeContinuedRequest(runtime, binding, sessionId, requestId, input, actual, options) {
-    let approval;
-    await appendAssistantMessage(runtime.persistence, sessionId, requestId, actual.output);
-    const checkpointRef = checkpointRefForState(sessionId, requestId, actual.state);
-    await runtime.setRequestStateAndEmit(sessionId, requestId, options.stateSequence, actual.state, {
-        previousState: options.previousState,
-        checkpointRef,
-    });
-    if (actual.state === "waiting_for_approval" && options.approvalSequence) {
-        approval = (await runtime.requestApprovalAndEmit(sessionId, requestId, input, actual.interruptContent, checkpointRef, options.approvalSequence)).approval;
-    }
-    return {
-        ...actual,
-        sessionId,
-        requestId,
-        approvalId: approval?.approvalId ?? actual.approvalId,
-        pendingActionId: approval?.pendingActionId ?? actual.pendingActionId,
-    };
-}
+async function r(a,t,e,p){p&&await a.appendSessionMessage(t,{role:"assistant",content:p,requestId:e,createdAt:new Date().toISOString()})}function v(a,t,e){return e==="waiting_for_approval"?`checkpoints/${a}/${t}/cp-1`:null}async function g(a,t,e){const p=await a.persistence.getRequestApprovals(t,e);for(const n of p)n.status==="pending"&&(await a.persistence.resolveApproval(t,e,n.approvalId,"expired"),await a.emit(t,e,6,"approval.resolved",{approvalId:n.approvalId,pendingActionId:n.pendingActionId,decision:"cancel",toolName:n.toolName}))}async function f(a,t,e,p,n){await g(a,t,e),await a.persistence.releaseRequestClaim(e),await a.persistence.clearRequestCancel(e),await a.persistence.clearRequestInput(t,e),await a.setRequestStateAndEmit(t,e,104,"cancelled",{previousState:p,...n?{error:n}:{}});const i=await a.persistence.getRequestMeta(t,e);return{sessionId:t,requestId:e,agentId:i.agentId,state:"cancelled",output:n?`cancelled: ${n}`:"cancelled"}}async function s(a,t,e,p,n,i,c){let o;await r(a.persistence,e,p,i.output);const l=v(e,p,i.state);return await a.setRequestStateAndEmit(e,p,c.stateSequence,i.state,{previousState:c.previousState,checkpointRef:l}),i.state==="waiting_for_approval"&&c.approvalSequence&&(o=(await a.requestApprovalAndEmit(e,p,n,i.interruptContent,l,c.approvalSequence)).approval),{...i,sessionId:e,requestId:p,approvalId:o?.approvalId??i.approvalId,pendingActionId:o?.pendingActionId??i.pendingActionId}}export{r as appendAssistantMessage,v as checkpointRefForState,g as expirePendingApprovals,f as finalizeCancelledRequest,s as finalizeContinuedRequest};

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

@@ -1,217 +1 @@
-import { describeRuntimeError } from "../../support/harness-support.js";
-import { isTerminalRequestState } from "./helpers.js";
-async function finalizeIfCancellationRequested(input) {
-    const cancellation = await input.getRequestCancellation(input.requestId);
-    if (!cancellation.requested) {
-        return null;
-    }
-    return input.finalizeCancelledRequest(input.sessionId, input.requestId, input.previousState, cancellation.reason);
-}
-function normalizeContinuationState(previousState) {
-    return previousState === "queued" ? "running" : previousState;
-}
-export async function resumeRequest(runtime, options) {
-    const approvalById = options.approvalId ? await runtime.getApprovalById(options.approvalId) : null;
-    const session = options.sessionId
-        ? await runtime.getSession(options.sessionId)
-        : approvalById
-            ? await runtime.getSession(approvalById.sessionId)
-            : null;
-    if (!session) {
-        throw new Error("resume requires either sessionId or approvalId");
-    }
-    const approval = approvalById ?? await runtime.resolveApprovalRecord(options, session);
-    const sessionId = approval.sessionId;
-    const requestId = approval.requestId;
-    const activeAgentId = session.currentAgentId ?? session.entryAgentId;
-    const binding = runtime.getBinding(activeAgentId);
-    if (!binding) {
-        throw new Error(`Unknown agent ${activeAgentId}`);
-    }
-    const resumePayload = runtime.buildResumePayload(binding, approval, options);
-    const cancelledBeforeResume = await finalizeIfCancellationRequested({
-        getRequestCancellation: runtime.getRequestCancellation,
-        finalizeCancelledRequest: runtime.finalizeCancelledRequest,
-        sessionId,
-        requestId,
-        previousState: session.currentState,
-    });
-    if (cancelledBeforeResume) {
-        return cancelledBeforeResume;
-    }
-    const checkpointRef = `checkpoints/${sessionId}/${requestId}/cp-1`;
-    await runtime.setRequestState(sessionId, requestId, "resuming", checkpointRef);
-    const releaseRequestSlot = await runtime.acquireRequestSlot(sessionId, requestId, "resuming", await runtime.resolvePersistedRequestPriority(sessionId, requestId));
-    try {
-        await runtime.saveRequestRecoveryIntent(sessionId, requestId, {
-            kind: "approval-decision",
-            savedAt: new Date().toISOString(),
-            checkpointRef,
-            resumePayload,
-            attempts: 0,
-        });
-        await runtime.emit(sessionId, requestId, 5, "request.resumed", {
-            resumeKind: "cross-restart",
-            checkpointRef,
-            state: "resuming",
-            approvalId: approval.approvalId,
-            pendingActionId: approval.pendingActionId,
-        });
-        await runtime.resolveApproval(sessionId, requestId, approval.approvalId, options.decision === "reject" ? "rejected" : options.decision === "edit" ? "edited" : "approved");
-        await runtime.emit(sessionId, requestId, 6, "approval.resolved", {
-            approvalId: approval.approvalId,
-            pendingActionId: approval.pendingActionId,
-            decision: options.decision ?? "approve",
-            toolName: approval.toolName,
-        });
-        const history = await runtime.listSessionMessages(sessionId);
-        const priorHistory = history.filter((message) => message.requestId !== requestId);
-        const requestInput = await runtime.loadRequestInput(sessionId, requestId);
-        const startedAt = Date.now();
-        try {
-            const actual = await runtime.invoke(binding, "", sessionId, requestId, resumePayload, priorHistory);
-            runtime.recordLlmSuccess(startedAt);
-            const cancelledAfterInvoke = await finalizeIfCancellationRequested({
-                getRequestCancellation: runtime.getRequestCancellation,
-                finalizeCancelledRequest: runtime.finalizeCancelledRequest,
-                sessionId,
-                requestId,
-                previousState: "resuming",
-            });
-            if (cancelledAfterInvoke) {
-                return cancelledAfterInvoke;
-            }
-            await runtime.clearRequestRecoveryIntent(sessionId, requestId);
-            const finalized = await runtime.finalizeContinuedRequest(binding, sessionId, requestId, requestInput, actual, {
-                previousState: "resuming",
-                stateSequence: 7,
-                approvalSequence: 8,
-            });
-            return {
-                ...finalized,
-                approvalId: finalized.approvalId ?? approval.approvalId,
-                pendingActionId: finalized.pendingActionId ?? approval.pendingActionId,
-            };
-        }
-        catch (error) {
-            runtime.recordLlmFailure(startedAt);
-            throw error;
-        }
-    }
-    finally {
-        await releaseRequestSlot();
-    }
-}
-export async function cancelRequestOperation(runtime, options) {
-    const request = await runtime.getRequest(options.requestId);
-    if (!request) {
-        throw new Error(`Unknown request ${options.requestId}`);
-    }
-    if (isTerminalRequestState(request.state)) {
-        return {
-            sessionId: request.sessionId,
-            requestId: request.requestId,
-            agentId: request.agentId,
-            state: request.state,
-            output: request.state,
-        };
-    }
-    await runtime.requestRequestCancel(request.requestId, options.reason);
-    if (request.state === "queued" || request.state === "waiting_for_approval" || request.state === "claimed") {
-        if (request.state === "queued") {
-            runtime.dropPendingRequestSlot(request.requestId);
-        }
-        return runtime.finalizeCancelledRequest(request.sessionId, request.requestId, request.state, options.reason);
-    }
-    await runtime.setRequestStateAndEmit(request.sessionId, request.requestId, 103, "cancelling", {
-        previousState: request.state,
-        ...(options.reason ? { error: options.reason } : {}),
-    });
-    return {
-        sessionId: request.sessionId,
-        requestId: request.requestId,
-        agentId: request.agentId,
-        state: "cancelling",
-        output: options.reason ? `cancelling: ${options.reason}` : "cancelling",
-    };
-}
-export async function executeQueuedRequestOperation(runtime, input) {
-    const { binding, message, sessionId, requestId, agentId } = input;
-    const options = input.options ?? {};
-    const previousState = options.previousState ?? "running";
-    const currentRequest = await runtime.persistence.getRequest(requestId);
-    if (currentRequest?.state === "cancelled") {
-        return {
-            sessionId: sessionId,
-            requestId: requestId,
-            agentId,
-            state: "cancelled",
-            output: "cancelled",
-        };
-    }
-    const cancelledBeforeInvoke = await finalizeIfCancellationRequested({
-        getRequestCancellation: runtime.getRequestCancellation,
-        finalizeCancelledRequest: runtime.finalizeCancelledRequest,
-        sessionId,
-        requestId,
-        previousState,
-    });
-    if (cancelledBeforeInvoke) {
-        return cancelledBeforeInvoke;
-    }
-    if (previousState === "queued") {
-        await runtime.emit(sessionId, requestId, 101, "request.dequeued", {
-            queuePosition: 0,
-            activeRequestCount: 0,
-            maxConcurrentRuns: 0,
-            recoveredOnStartup: true,
-        });
-        await runtime.setRequestStateAndEmit(sessionId, requestId, 102, "running", {
-            previousState: "queued",
-        });
-    }
-    const continuationState = normalizeContinuationState(previousState);
-    try {
-        const actual = await runtime.invokeWithHistory(binding, message, sessionId, requestId, undefined, options.priorHistory, {
-            context: options.context,
-            state: options.state,
-            files: options.files,
-        });
-        const cancelledAfterInvoke = await finalizeIfCancellationRequested({
-            getRequestCancellation: runtime.getRequestCancellation,
-            finalizeCancelledRequest: runtime.finalizeCancelledRequest,
-            sessionId,
-            requestId,
-            previousState: continuationState,
-        });
-        if (cancelledAfterInvoke) {
-            return cancelledAfterInvoke;
-        }
-        const finalized = await runtime.finalizeContinuedRequest(binding, sessionId, requestId, message, actual, {
-            previousState: continuationState,
-            stateSequence: options.stateSequence ?? 103,
-            approvalSequence: options.approvalSequence ?? 104,
-        });
-        return {
-            ...finalized,
-            agentId,
-        };
-    }
-    catch (error) {
-        await runtime.emitSyntheticFallback(sessionId, requestId, agentId, error);
-        await runtime.setRequestStateAndEmit(sessionId, requestId, 104, "failed", {
-            previousState: continuationState,
-            error: describeRuntimeError(error),
-        });
-        return {
-            sessionId: sessionId,
-            requestId: requestId,
-            agentId,
-            state: "failed",
-            output: runtime.renderRuntimeFailure(error),
-        };
-    }
-    finally {
-        await runtime.persistence.clearRequestInput(sessionId, requestId);
-    }
-}
+import{describeRuntimeError as C}from"../../support/harness-support.js";import{isTerminalRequestState as y}from"./helpers.js";async function I(e){const s=await e.getRequestCancellation(e.requestId);return s.requested?e.finalizeCancelledRequest(e.sessionId,e.requestId,e.previousState,s.reason):null}function A(e){return e==="queued"?"running":e}async function k(e,s){const t=s.approvalId?await e.getApprovalById(s.approvalId):null,o=s.sessionId?await e.getSession(s.sessionId):t?await e.getSession(t.sessionId):null;if(!o)throw new Error("resume requires either sessionId or approvalId");const n=t??await e.resolveApprovalRecord(s,o),a=n.sessionId,i=n.requestId,r=o.currentAgentId??o.entryAgentId,l=e.getBinding(r);if(!l)throw new Error(`Unknown agent ${r}`);const p=e.buildResumePayload(l,n,s),u=await I({getRequestCancellation:e.getRequestCancellation,finalizeCancelledRequest:e.finalizeCancelledRequest,sessionId:a,requestId:i,previousState:o.currentState});if(u)return u;const c=`checkpoints/${a}/${i}/cp-1`;await e.setRequestState(a,i,"resuming",c);const d=await e.acquireRequestSlot(a,i,"resuming",await e.resolvePersistedRequestPriority(a,i));try{await e.saveRequestRecoveryIntent(a,i,{kind:"approval-decision",savedAt:new Date().toISOString(),checkpointRef:c,resumePayload:p,attempts:0}),await e.emit(a,i,5,"request.resumed",{resumeKind:"cross-restart",checkpointRef:c,state:"resuming",approvalId:n.approvalId,pendingActionId:n.pendingActionId}),await e.resolveApproval(a,i,n.approvalId,s.decision==="reject"?"rejected":s.decision==="edit"?"edited":"approved"),await e.emit(a,i,6,"approval.resolved",{approvalId:n.approvalId,pendingActionId:n.pendingActionId,decision:s.decision??"approve",toolName:n.toolName});const g=(await e.listSessionMessages(a)).filter(q=>q.requestId!==i),S=await e.loadRequestInput(a,i),v=Date.now();try{const q=await e.invoke(l,"",a,i,p,g);e.recordLlmSuccess(v);const w=await I({getRequestCancellation:e.getRequestCancellation,finalizeCancelledRequest:e.finalizeCancelledRequest,sessionId:a,requestId:i,previousState:"resuming"});if(w)return w;await e.clearRequestRecoveryIntent(a,i);const f=await e.finalizeContinuedRequest(l,a,i,S,q,{previousState:"resuming",stateSequence:7,approvalSequence:8});return{...f,approvalId:f.approvalId??n.approvalId,pendingActionId:f.pendingActionId??n.pendingActionId}}catch(q){throw e.recordLlmFailure(v),q}}finally{await d()}}async function x(e,s){const t=await e.getRequest(s.requestId);if(!t)throw new Error(`Unknown request ${s.requestId}`);return y(t.state)?{sessionId:t.sessionId,requestId:t.requestId,agentId:t.agentId,state:t.state,output:t.state}:(await e.requestRequestCancel(t.requestId,s.reason),t.state==="queued"||t.state==="waiting_for_approval"||t.state==="claimed"?(t.state==="queued"&&e.dropPendingRequestSlot(t.requestId),e.finalizeCancelledRequest(t.sessionId,t.requestId,t.state,s.reason)):(await e.setRequestStateAndEmit(t.sessionId,t.requestId,103,"cancelling",{previousState:t.state,...s.reason?{error:s.reason}:{}}),{sessionId:t.sessionId,requestId:t.requestId,agentId:t.agentId,state:"cancelling",output:s.reason?`cancelling: ${s.reason}`:"cancelling"}))}async function E(e,s){const{binding:t,message:o,sessionId:n,requestId:a,agentId:i}=s,r=s.options??{},l=r.previousState??"running";if((await e.persistence.getRequest(a))?.state==="cancelled")return{sessionId:n,requestId:a,agentId:i,state:"cancelled",output:"cancelled"};const u=await I({getRequestCancellation:e.getRequestCancellation,finalizeCancelledRequest:e.finalizeCancelledRequest,sessionId:n,requestId:a,previousState:l});if(u)return u;l==="queued"&&(await e.emit(n,a,101,"request.dequeued",{queuePosition:0,activeRequestCount:0,maxConcurrentRuns:0,recoveredOnStartup:!0}),await e.setRequestStateAndEmit(n,a,102,"running",{previousState:"queued"}));const c=A(l);try{const d=await e.invokeWithHistory(t,o,n,a,void 0,r.priorHistory,{context:r.context,state:r.state,files:r.files}),R=await I({getRequestCancellation:e.getRequestCancellation,finalizeCancelledRequest:e.finalizeCancelledRequest,sessionId:n,requestId:a,previousState:c});return R||{...await e.finalizeContinuedRequest(t,n,a,o,d,{previousState:c,stateSequence:r.stateSequence??103,approvalSequence:r.approvalSequence??104}),agentId:i}}catch(d){return await e.emitSyntheticFallback(n,a,i,d),await e.setRequestStateAndEmit(n,a,104,"failed",{previousState:c,error:C(d)}),{sessionId:n,requestId:a,agentId:i,state:"failed",output:e.renderRuntimeFailure(d)}}finally{await e.persistence.clearRequestInput(n,a)}}export{x as cancelRequestOperation,E as executeQueuedRequestOperation,k as resumeRequest};