@archmax-ai/harness 0.0.0

package/dist/sessions/resolve.js

@@ -0,0 +1,145 @@
+import { MANUAL_TRIGGER, parseSessionPath, resolveSessionId, } from "../machine/triggers.js";
+import { isFinished, WORKFLOW_STATUSES } from "../workflow/state.js";
+/**
+ * Thrown when a firing maps to a session whose turn is still in progress: a
+ * session has a single writer, so the firing must wait. A human-parked session
+ * is *not* this case — it resolves to `reply`.
+ */
+export class SessionNotResumableError extends Error {
+    sessionId;
+    status;
+    constructor(sessionId, status) {
+        super(`Session '${sessionId}' has a turn in progress (status '${status ?? "unknown"}'). A ` +
+            `session has a single writer: retry once the turn parks or ends.`);
+        this.sessionId = sessionId;
+        this.status = status;
+        this.name = "SessionNotResumableError";
+    }
+}
+/** Thrown when a firing names a trigger no state of the workflow declares. */
+export class UnknownSessionTriggerError extends Error {
+    trigger;
+    constructor(trigger) {
+        super(`No state declares trigger '${trigger}', and no parked session is awaiting it, so there ` +
+            `is nowhere for this firing to go. Declare it under the 'triggers:' of the state a run ` +
+            `should start in, or deliver the firing to a session parked on it — naming the session, ` +
+            `or a 'sessionPath' to find it by.`);
+        this.trigger = trigger;
+        this.name = "UnknownSessionTriggerError";
+    }
+}
+/**
+ * Derive a firing's session id: the explicit one, else the invoking trigger's
+ * declared path resolved over the firing's variables, else a minted id (the
+ * firing is its own session). Every turn belongs to exactly one session.
+ */
+export function deriveSessionId(path, input, nativeId) {
+    const explicit = input.sessionId?.trim();
+    if (explicit)
+        return { sessionId: explicit, native: false };
+    if (path) {
+        const resolved = resolveSessionId(path, input.variables ?? {});
+        if (resolved !== undefined)
+            return { sessionId: resolved, native: false };
+        return { sessionId: nativeId, native: true, unresolvedPath: path };
+    }
+    return { sessionId: nativeId, native: true };
+}
+/**
+ * Resolve and classify a firing. Never invokes the graph: the caller decides
+ * whether to start the run or deliver into it.
+ */
+export async function resolveSession(machine, lookup, input, onWarning) {
+    const triggerId = input.trigger?.id ?? MANUAL_TRIGGER;
+    const { sessionId, native, unresolvedPath } = deriveSessionId(sessionPathFor(machine, triggerId, input.sessionPath), input, lookup.mintSessionId());
+    if (unresolvedPath) {
+        onWarning?.(`Trigger '${triggerId}' declares session path '${unresolvedPath.raw}', which this firing's ` +
+            `variables do not resolve. The firing is its own session ('${sessionId}') and cannot be ` +
+            `continued by a later firing for the same conversation.`);
+    }
+    // Where a *first* turn begins. A session that already has a position keeps it
+    // (below), so an unknown trigger id is only fatal at a session's opening.
+    const entryState = machine.startStateForTrigger(triggerId);
+    const openAt = (startState) => ({
+        sessionId,
+        disposition: "turn",
+        startState,
+        native,
+    });
+    const firstTurn = () => {
+        if (!entryState)
+            throw new UnknownSessionTriggerError(triggerId);
+        return openAt(entryState);
+    };
+    // A minted id names a session that does not exist yet: nothing to look up.
+    if (native)
+        return firstTurn();
+    const session = await lookup.findSession(sessionId);
+    // Projected from the session's own checkpoint: an absent or unreadable session
+    // is one that has not run yet.
+    if (!session)
+        return firstTurn();
+    if (isFinished(session.status)) {
+        // The previous turn ended; this firing is the next turn of the same
+        // conversation, continuing from the state that turn left it in (the trigger's
+        // entry state applies to a session's opening only). Only a position the
+        // *current* definition still declares is reported: the graph falls back to
+        // the trigger's entry state for one it cannot route to, and resolution must
+        // say the same thing.
+        const retained = session.workflowState;
+        const routable = retained != null && Object.hasOwn(machine.spec.states, retained);
+        return openAt(routable ? retained : (entryState ?? machine.entry));
+    }
+    // Parked at a human state: a person holds the run, so the firing cannot move
+    // it — but it is a message in a live conversation, so it is answered where the
+    // session stands and the park is left exactly as it was.
+    if (session.status === WORKFLOW_STATUSES.awaitingDecision) {
+        return {
+            sessionId,
+            disposition: "reply",
+            ...(session.workflowState
+                ? { state: session.workflowState, node: session.workflowState }
+                : {}),
+            native: false,
+        };
+    }
+    if (session.status !== WORKFLOW_STATUSES.awaitingInput) {
+        throw new SessionNotResumableError(sessionId, session.status);
+    }
+    // Parked awaiting an event, and any event will do: the session resumes the
+    // state it parked in, so there is no awaited id to match the firing against.
+    // The open turn takes the firing rather than a competing turn starting.
+    return {
+        sessionId,
+        disposition: "resume",
+        state: session.workflowState,
+        node: session.workflowState,
+        native: false,
+    };
+}
+/**
+ * The path this firing reads its id from: the caller's override if it supplied
+ * one, else what the invoking trigger declares on the state it enters — one
+ * parser for both.
+ */
+function sessionPathFor(machine, triggerId, override) {
+    if (override === undefined || override.trim() === "") {
+        return machine.sessionPathForTrigger(triggerId);
+    }
+    const parsed = parseSessionPath(override);
+    if (parsed.error)
+        throw new InvalidSessionPathError(override, parsed.error);
+    return parsed.path;
+}
+/** Thrown when a caller-supplied session path is not a usable dotted path. */
+export class InvalidSessionPathError extends Error {
+    path;
+    reason;
+    constructor(path, reason) {
+        super(`the caller-supplied path '${path}' is not a usable session path: ${reason}`);
+        this.path = path;
+        this.reason = reason;
+        this.name = "InvalidSessionPathError";
+    }
+}
+//# sourceMappingURL=resolve.js.map

package/dist/sessions/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/sessions/resolve.ts"],"names":[],"mappings":"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"}

package/dist/sessions/resume.d.ts

@@ -0,0 +1,242 @@
+import { type RunnableConfig } from "@langchain/core/runnables";
+import type { IntrospectableStateGraph } from "../core/deepagents.js";
+import { type UsageSummary } from "../core/usage.js";
+import { type VariableStore } from "../machine/variables.js";
+import { type ParkChannel, type PendingDecision, type PendingInput, type TrailStep, type WorkflowStatus } from "../workflow/state.js";
+export type { IntrospectableStateGraph };
+/** The value a decision resumes a session parked at a human state with. */
+export interface DecisionResolution {
+    /**
+     * The state the person selected to route to — one of the parked state's
+     * declared transition targets. The person picks the edge; no model interprets
+     * the choice.
+     */
+    target: string;
+    /** Optional free-form comment explaining the choice; recorded and passed on. */
+    comment?: string;
+}
+/**
+ * The value a reply resumes a parked session with: something the person said
+ * while a decision is pending. Answered, never acted on — the session stays
+ * parked at the same state, and only a {@link DecisionResolution} moves it.
+ */
+export interface MessageResolution {
+    message: string;
+}
+/**
+ * Whether a resume payload is a message rather than a decision or a delivery.
+ * Told apart **structurally** — a `target` routes, a `trigger` is delivered (and
+ * may carry a message with it), a `message` alone is answered — never by reading
+ * the words: "yes, approve it" typed into the chat is not a decision.
+ */
+export declare function isMessageResume(resume: unknown): resume is MessageResolution;
+/**
+ * A firing delivered into a parked session: the trigger id the session adopts as
+ * its current one, plus the variables the event carried. Nothing is routed by
+ * the id: the session continues in the state it parked in.
+ */
+export interface TriggerDelivery {
+    trigger: {
+        id: string;
+    };
+    variables?: Record<string, unknown>;
+    /**
+     * What a person said with the firing — a chat message that arrived while the
+     * session waited. Appended to the transcript as the person's own message in
+     * the same resume that delivers the firing, so it can neither land on a session
+     * whose park is gone nor be separated from the arrival by a crash between two
+     * writes. Blank is the same as absent.
+     */
+    message?: string;
+}
+/**
+ * The three ways a parked session resumes: a person decides, a person replies,
+ * the host delivers — one union, so `send()` takes one argument shape.
+ */
+export type ResumePayload = {
+    decision: DecisionResolution;
+} | {
+    message: string;
+} | {
+    delivery: TriggerDelivery;
+};
+/** Thrown when a decision or reply targets a session that is not parked at a human state. */
+export declare class SessionNotParkedError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
+/** Thrown when a decision names a target that is not one of the parked state's transitions. */
+export declare class InvalidDecisionTargetError extends Error {
+    readonly sessionId: string;
+    readonly target: string | undefined;
+    readonly validTargets: string[];
+    constructor(sessionId: string, target: string | undefined, validTargets: string[]);
+}
+/** Thrown when a reply is sent to a parked session without any content. */
+export declare class EmptyMessageError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
+/** Thrown when a delivery targets a session that is not parked awaiting input. */
+export declare class SessionNotAwaitingInputError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
+/** Thrown when a delivery carries no trigger id to record as the session's current one. */
+export declare class MissingDeliveryTriggerError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
+/**
+ * The child a parked session's pending decision belongs to. When a delegated
+ * child parks at its own human state, the calling session parks with it and
+ * presents the child's decision as its own; this says so, and names the child.
+ * A decision on the parent (`decide`, `send({ decision })`) is handed to that
+ * child — the caller addresses the parent session throughout.
+ */
+export interface DelegatedPark {
+    /** The child workflow's slug. */
+    workflow: string;
+    /** The child's own session id (`<parent>~<identity>`), when the parent's id was known to the reader. */
+    sessionId?: string;
+    /** The dispatch identity the child's session id derives from: `<state>:<workflow>:<ordinal>`. */
+    identity: string;
+    /** The dispatch this park belongs to, as the `sub-workflow-*` events name it. */
+    dispatchId: string;
+    /** The tool call in the parent's transcript the child answers. */
+    toolCallId: string;
+    /** The parent state that made the call — where the parent parks, and resumes. */
+    state: string;
+}
+/** Outcome of resuming a session parked at a human state with a decision. */
+export interface DecideOutcome {
+    /** Session status after the resume settled (`running`, `completed`, …). */
+    status?: WorkflowStatus;
+    /** Workflow state the session landed in after resuming. */
+    workflowState?: string;
+    /**
+     * Whether the session parked again, on **either** channel: a decision can
+     * route into another human state or into a state that then waits for an event.
+     */
+    reparked: boolean;
+    /** Which channel it re-parked on, when it did. Pairs with {@link state}. */
+    parkedChannel?: ParkChannel;
+    /** The state the session re-parked at — a human state or a waiting state. */
+    state?: string;
+    /** @deprecated Older spelling of {@link state}; kept for one release. */
+    node?: string;
+    /** Present when the pending decision is a delegated child's, not this session's own. */
+    delegation?: DelegatedPark;
+    /** What the session last said to the person — a finished turn's answer, or a park's message. Empty when it said nothing. */
+    reply: string;
+    /** Full message history after the resume, for building a session view. */
+    messages: unknown[];
+    /** The session's full committed audit trail after the resume settled. */
+    auditTrail: TrailStep[];
+}
+/**
+ * Outcome of replying to a session parked at a human state. Always a re-park at
+ * the same state: a message is answered, never acted on.
+ */
+export interface ReplyOutcome extends DecideOutcome {
+    /** The state the session is (still) parked at. */
+    state: string;
+    /** @deprecated Older spelling of {@link state}; kept for one release. */
+    node: string;
+    /** Always `decision`: a message is answered where a person still holds the session. */
+    parkedChannel: ParkChannel;
+}
+/** @deprecated Older spelling of {@link ReplyOutcome}; kept for one release. */
+export type RespondOutcome = ReplyOutcome;
+/** What a delivery produced: a decision's shape plus the variables it seeded. */
+export interface DeliverOutcome extends DecideOutcome {
+    /** The session's variables after the delivery seeded its own. */
+    variables: VariableStore;
+    /** Which channel the session re-parked in, when it did. */
+    parkedChannel?: ParkChannel;
+}
+/** Everything any resume settles to — the union of the three outcomes above. */
+export interface ResumeOutcome extends DecideOutcome {
+    variables: VariableStore;
+    /** The park record a re-parked session presents, when it re-parked. */
+    pending?: PendingDecision | PendingInput;
+    /** Cumulative usage from the checkpoint, when anything was spent. */
+    usage?: UsageSummary;
+}
+/** How `send()` entered the session. */
+export type SendDisposition = "turn" | "decide" | "reply" | "deliver";
+/**
+ * What one `send()` on a session produced, whichever way it entered: a turn, a
+ * decision, a reply or a delivery. One shape for a host and the CLI.
+ */
+export interface Outcome {
+    /** Completed, parked (on either channel), or rejected by governance. */
+    kind: "completed" | "parked" | "rejected";
+    /** How the session was entered. */
+    disposition: SendDisposition;
+    /** Session status after the turn settled. */
+    status?: WorkflowStatus;
+    /** The state the session is in — for a park, the state it is parked at. */
+    state?: string;
+    /** Which channel a parked session awaits. */
+    parkedChannel?: ParkChannel;
+    /** The park record a parked session presents: what a person or a host needs to resume it. */
+    pending?: PendingDecision | PendingInput;
+    /**
+     * When `kind` is `parked` on the `decision` channel because a **delegated
+     * child** parked: which child, and which call. Absent for the session's own
+     * park. A host reads this instead of folding `sub-workflow-*` events or
+     * shape-testing the child's interrupt.
+     */
+    delegation?: DelegatedPark;
+    /** What the session last said to the person. Empty when it said nothing. */
+    reply: string;
+    /** Full message history after the turn. */
+    messages: unknown[];
+    /** The session's committed audit trail. */
+    auditTrail: TrailStep[];
+    /** The session's variables, keyed by name. */
+    variables: VariableStore;
+    /** Cumulative usage from the checkpoint, when anything was spent. */
+    usage?: UsageSummary;
+}
+/**
+ * Read a session that must be parked in `status`, or `null`. "Parked" is two
+ * conditions — the checkpointed status *and* a pending interrupt — so every
+ * resume asks it here.
+ */
+export declare function readParkedSession(graph: IntrospectableStateGraph, sessionId: string, status: string): Promise<Record<string, unknown> | null>;
+/**
+ * The settled values of a turn or a resume, read into a {@link ResumeOutcome}.
+ * `sessionId` is the session the values belong to, when the caller knows it; it
+ * lets a delegated park name the child's session id.
+ */
+export declare function settle(result: Record<string, unknown>, sessionId?: string): ResumeOutcome;
+/** The {@link Outcome} a settled {@link ResumeOutcome} amounts to. */
+export declare function outcomeOf(settled: ResumeOutcome, disposition: SendDisposition): Outcome;
+/**
+ * Resume a parked session with a decision, a reply or a delivery. Everything is
+ * validated before the graph is touched; the invoke result *is* the resumed state.
+ */
+export declare function resume(graph: IntrospectableStateGraph, sessionId: string, payload: ResumePayload, config?: RunnableConfig): Promise<ResumeOutcome>;
+/**
+ * Resume a session parked at a human state with the person's decision. Throws
+ * {@link SessionNotParkedError} when the session is not awaiting a decision, and
+ * {@link InvalidDecisionTargetError} when `target` is not a declared transition.
+ */
+export declare function decide(graph: IntrospectableStateGraph, sessionId: string, resolution: DecisionResolution, config?: RunnableConfig): Promise<DecideOutcome>;
+/**
+ * Reply to a session parked at a human state and get its answer: a turn with no
+ * tools, after which the session stays parked at the same state with the same
+ * pending decision. Throws {@link SessionNotParkedError} and {@link EmptyMessageError}.
+ */
+export declare function reply(graph: IntrospectableStateGraph, sessionId: string, message: string, config?: RunnableConfig): Promise<ReplyOutcome>;
+/** @deprecated Older spelling of {@link reply}; kept for one release. */
+export declare const respond: typeof reply;
+/**
+ * Resume a parked session with a delivered firing: the session continues in the
+ * state it parked in, the delivered id becomes its current trigger, and the
+ * variables seed what the event carried. Throws {@link SessionNotAwaitingInputError}
+ * and {@link MissingDeliveryTriggerError}.
+ */
+export declare function deliver(graph: IntrospectableStateGraph, sessionId: string, delivery: TriggerDelivery, config?: RunnableConfig): Promise<DeliverOutcome>;