@mongodb-js/agent-engine-runner-shared 0.11.3

package/dist/workflow/context.js

@@ -0,0 +1,350 @@
+/** Request-local durable attempt identity, positions, and observed activities. */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { create, fromJson, toJson } from "@bufbuild/protobuf";
+import { ActivityCommandSchema, } from "../generated/workflow/v1/activity_pb.js";
+import { ActivityPositionSchema, OperationPathSchema, OperationPathSegmentSchema, } from "../generated/workflow/v1/common_pb.js";
+const storage = new AsyncLocalStorage();
+/**
+ * Nested operation-path resolvers are a ContextVar analog: they must follow
+ * the async chain, not a mutable field on the shared attempt holder. Sibling
+ * `resolverStorage.run` scopes then keep distinct paths after `await`.
+ */
+const resolverStorage = new AsyncLocalStorage();
+export class UnsupportedChildOperationFanOutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnsupportedChildOperationFanOutError";
+    }
+}
+function pathKeyFromSegments(segments) {
+    return JSON.stringify(segments.map((segment) => [segment.name, Number(segment.ordinal)]));
+}
+function clonePosition(position) {
+    return fromJson(ActivityPositionSchema, toJson(ActivityPositionSchema, position));
+}
+function activityPositionKey(position) {
+    return [
+        Number(position.stepOrdinal),
+        pathKeyFromSegments(position.operationPath?.segments ?? []),
+        Number(position.activityOrdinal),
+    ];
+}
+function compareObservedPositions(left, right) {
+    const leftSegments = left.operationPath?.segments ?? [];
+    const rightSegments = right.operationPath?.segments ?? [];
+    const shared = Math.min(leftSegments.length, rightSegments.length);
+    for (let index = 0; index < shared; index += 1) {
+        const leftSegment = leftSegments[index];
+        const rightSegment = rightSegments[index];
+        if (leftSegment === undefined || rightSegment === undefined) {
+            break;
+        }
+        if (leftSegment.name < rightSegment.name)
+            return -1;
+        if (leftSegment.name > rightSegment.name)
+            return 1;
+        const ordinalCmp = Number(leftSegment.ordinal) - Number(rightSegment.ordinal);
+        if (ordinalCmp !== 0)
+            return ordinalCmp;
+    }
+    if (leftSegments.length !== rightSegments.length) {
+        return leftSegments.length - rightSegments.length;
+    }
+    return Number(left.activityOrdinal) - Number(right.activityOrdinal);
+}
+class ObservedActivityPositions {
+    positions = new Map();
+    record(position) {
+        const key = JSON.stringify(activityPositionKey(position));
+        this.positions.set(key, clonePosition(position));
+    }
+    forStep(stepOrdinal) {
+        return [...this.positions.values()]
+            .filter((position) => Number(position.stepOrdinal) === stepOrdinal)
+            .sort(compareObservedPositions);
+    }
+}
+class InterruptedActivities {
+    items = [];
+    record(command, controlFlow) {
+        // Settlement needs the command as admitted, even if the caller mutates it.
+        this.items.push({
+            command: fromJson(ActivityCommandSchema, toJson(ActivityCommandSchema, command)),
+            controlFlow,
+        });
+    }
+    forStep(stepOrdinal) {
+        return this.items.filter((item) => item.command.position?.stepOrdinal === BigInt(stepOrdinal));
+    }
+}
+class ActivityReconstruction {
+    activityIds = new Set();
+    interruptCounts = new Map();
+    replace(activityIds) {
+        this.activityIds = new Set(activityIds);
+    }
+    contains(activityId) {
+        return this.activityIds.has(activityId);
+    }
+    recordInterrupt(activityId) {
+        if (!this.activityIds.has(activityId)) {
+            throw new Error(`activity "${activityId}" is not being reconstructed`);
+        }
+        const count = (this.interruptCounts.get(activityId) ?? 0) + 1;
+        this.interruptCounts.set(activityId, count);
+        return count;
+    }
+}
+class ActivityOrdinalAllocator {
+    nextByPath = new Map();
+    byPathAndKey = new Map();
+    preallocate(path, keys) {
+        return keys.map((key) => this.allocate(path, key));
+    }
+    allocate(path, key) {
+        if (key !== undefined && key === "") {
+            throw new Error("activity ordinal key must be non-empty");
+        }
+        if (key !== undefined) {
+            const pathKey = JSON.stringify([path, key]);
+            const existing = this.byPathAndKey.get(pathKey);
+            if (existing !== undefined)
+                return existing;
+            const ordinal = this.nextByPath.get(path) ?? 1;
+            this.nextByPath.set(path, ordinal + 1);
+            this.byPathAndKey.set(pathKey, ordinal);
+            return ordinal;
+        }
+        const ordinal = this.nextByPath.get(path) ?? 1;
+        this.nextByPath.set(path, ordinal + 1);
+        return ordinal;
+    }
+}
+class ChildOperationPathAllocator {
+    nextOrdinalByChild = new Map();
+    ordinalByOccurrence = new Map();
+    keysByStepChild = new Map();
+    /**
+     * Assign ordinals to a complete sibling batch in list order, before
+     * concurrent same-name dispatch. Idempotent per occurrence key. The batch is
+     * validated before any assignment so a malformed or duplicate sibling
+     * identity cannot leave a partial reservation.
+     */
+    preallocate(path, stepOrdinal, boundaries) {
+        if (boundaries.length === 0) {
+            throw new Error("child operation name and occurrence key must be non-empty");
+        }
+        const seen = new Set();
+        for (const boundary of boundaries) {
+            if (!boundary.name || !boundary.occurrenceKey) {
+                throw new Error("child operation name and occurrence key must be non-empty");
+            }
+            const identity = JSON.stringify([boundary.name, boundary.occurrenceKey]);
+            if (seen.has(identity)) {
+                throw new UnsupportedChildOperationFanOutError(`child '${boundary.name}' has duplicate occurrence ` +
+                    `'${boundary.occurrenceKey}' in the same batch`);
+            }
+            seen.add(identity);
+        }
+        return boundaries.map((boundary) => this.assign(path, stepOrdinal, boundary, true));
+    }
+    resolve(boundaries, stepOrdinal) {
+        const segments = [
+            create(OperationPathSegmentSchema, { name: "agent", ordinal: 1n }),
+        ];
+        for (const boundary of boundaries) {
+            const parent = pathKeyFromSegments(segments);
+            const ordinal = this.assign(parent, stepOrdinal, boundary, false);
+            segments.push(create(OperationPathSegmentSchema, {
+                name: boundary.name,
+                ordinal: BigInt(ordinal),
+            }));
+        }
+        return create(OperationPathSchema, { segments });
+    }
+    assign(parent, stepOrdinal, boundary, preallocating) {
+        if (!boundary.name || !boundary.occurrenceKey) {
+            throw new Error("child operation name and occurrence key must be non-empty");
+        }
+        const childKey = JSON.stringify([parent, boundary.name]);
+        const stepChildKey = JSON.stringify([stepOrdinal, childKey]);
+        const occurrenceKey = JSON.stringify([
+            stepChildKey,
+            boundary.occurrenceKey,
+        ]);
+        const existing = this.ordinalByOccurrence.get(occurrenceKey);
+        if (existing === undefined) {
+            const seenKeys = this.keysByStepChild.get(stepChildKey);
+            if (seenKeys && seenKeys.size > 0 && !preallocating) {
+                throw new UnsupportedChildOperationFanOutError(`child '${boundary.name}' has multiple occurrences in root step ` +
+                    `${stepOrdinal}; deterministic preallocation is required`);
+            }
+            const ordinal = this.nextOrdinalByChild.get(childKey) ?? 1;
+            this.nextOrdinalByChild.set(childKey, ordinal + 1);
+            this.ordinalByOccurrence.set(occurrenceKey, ordinal);
+        }
+        const keys = this.keysByStepChild.get(stepChildKey) ?? new Set();
+        keys.add(boundary.occurrenceKey);
+        this.keysByStepChild.set(stepChildKey, keys);
+        return this.ordinalByOccurrence.get(occurrenceKey);
+    }
+}
+function rootOperationPath() {
+    return create(OperationPathSchema, {
+        segments: [
+            create(OperationPathSegmentSchema, { name: "agent", ordinal: 1n }),
+        ],
+    });
+}
+function initialStepOrdinal(context) {
+    const lineage = context.branchLineage;
+    if (lineage === undefined)
+        return 1;
+    const source = lineage.sourceWorkflowIdentity;
+    if (source === undefined ||
+        !source.sessionId ||
+        !source.executionId ||
+        lineage.sourceStepOrdinal <= 0n ||
+        !lineage.sourceStateHash) {
+        throw new Error("branch_lineage must identify a positive immutable source cutoff");
+    }
+    return Number(lineage.sourceStepOrdinal) + 1;
+}
+function bindHolder(attempt) {
+    return {
+        attempt,
+        step: { value: initialStepOrdinal(attempt) },
+        activityOrdinals: new ActivityOrdinalAllocator(),
+        childPaths: new ChildOperationPathAllocator(),
+        pendingChildBatch: { boundaries: [] },
+        observed: new ObservedActivityPositions(),
+        interrupted: new InterruptedActivities(),
+        reconstruction: new ActivityReconstruction(),
+    };
+}
+function activeHolder() {
+    const holder = storage.getStore();
+    if (holder === undefined || holder.attempt === null)
+        return undefined;
+    return holder;
+}
+function requireHolder(what) {
+    const holder = activeHolder();
+    if (holder === undefined) {
+        throw new Error(`${what} requires an active durable attempt context; ` +
+            "bind AttemptContext before admitting activities or committing steps");
+    }
+    return holder;
+}
+export function runWithAttemptContext(attempt, fn) {
+    const holder = bindHolder(attempt);
+    const close = () => {
+        holder.attempt = null;
+    };
+    try {
+        const result = storage.run(holder, fn);
+        if (result instanceof Promise) {
+            return result.finally(close);
+        }
+        close();
+        return result;
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+}
+export function currentAttemptContext() {
+    return storage.getStore()?.attempt ?? null;
+}
+export function currentStepOrdinal() {
+    const holder = requireHolder("step_ordinal");
+    if (holder.step.value <= 0) {
+        throw new Error("step_ordinal requires an active durable attempt context; " +
+            "bind AttemptContext before admitting activities or committing steps");
+    }
+    return holder.step.value;
+}
+export function currentOperationPath() {
+    const holder = activeHolder();
+    const resolver = resolverStorage.getStore();
+    if (holder === undefined || resolver === undefined) {
+        return rootOperationPath();
+    }
+    return holder.childPaths.resolve(resolver(), currentStepOrdinal());
+}
+export function runWithOperationPathResolver(resolver, fn) {
+    return resolverStorage.run(resolver, fn);
+}
+export function childOperationBoundaryScope(boundary, fn) {
+    // Append one child boundary to the active framework operation path.
+    //
+    // Framework adapters use this around dynamic child execution whose boundary
+    // is not visible in the parent graph topology. If a parent resolver is
+    // active, its boundaries are captured before the child changes framework
+    // runtime context and remain the prefix; otherwise the supplied boundary
+    // starts the nested path below the fixed root agent segment.
+    const parentResolver = resolverStorage.getStore();
+    const parentBoundaries = parentResolver?.() ?? [];
+    return runWithOperationPathResolver(() => [...parentBoundaries, boundary], fn);
+}
+export function recordObservedActivity(position) {
+    activeHolder()?.observed.record(position);
+}
+export function observedActivityPositions(stepOrdinal) {
+    return activeHolder()?.observed.forStep(stepOrdinal) ?? [];
+}
+export function recordInterruptedActivity(command, controlFlow) {
+    activeHolder()?.interrupted.record(command, controlFlow);
+}
+export function interruptedActivities(stepOrdinal) {
+    return activeHolder()?.interrupted.forStep(stepOrdinal) ?? [];
+}
+export function setActivityReconstructionIds(activityIds) {
+    activeHolder()?.reconstruction.replace(activityIds);
+}
+export function activityRequiresReconstruction(activityId) {
+    return activeHolder()?.reconstruction.contains(activityId) ?? false;
+}
+export function recordReconstructedActivityInterrupt(activityId) {
+    return requireHolder("activity reconstruction").reconstruction.recordInterrupt(activityId);
+}
+export function advanceStepOrdinal(committedStepOrdinal) {
+    if (committedStepOrdinal <= 0) {
+        throw new Error("committed step_ordinal must be positive");
+    }
+    const holder = requireHolder("step_ordinal");
+    holder.step.value = committedStepOrdinal + 1;
+    return holder.step.value;
+}
+export function toolActivityKey(toolCallId) {
+    if (!toolCallId) {
+        throw new Error("tool_call_id must be non-empty");
+    }
+    return `tool:${toolCallId}`;
+}
+export function allocateActivityOrdinal(key) {
+    const holder = requireHolder("activity_ordinal");
+    return holder.activityOrdinals.allocate(pathKeyFromSegments(currentOperationPath().segments), key);
+}
+export function preallocateActivityOrdinals(keys) {
+    const holder = requireHolder("activity_ordinal");
+    return holder.activityOrdinals.preallocate(pathKeyFromSegments(currentOperationPath().segments), keys);
+}
+export function preallocateChildOperationOrdinals(boundaries) {
+    const holder = requireHolder("child operation paths");
+    return holder.childPaths.preallocate(pathKeyFromSegments(currentOperationPath().segments), currentStepOrdinal(), boundaries);
+}
+export function currentPendingChildOperationBatch() {
+    return activeHolder()?.pendingChildBatch.boundaries ?? [];
+}
+export function setPendingChildOperationBatch(boundaries) {
+    // Replace in the shared attempt holder so detached worker copies observe
+    // the batch without a process-global map. The active-holder gate keeps
+    // detached callbacks from touching the batch after the attempt closes,
+    // matching every other attempt-scoped accessor.
+    const holder = activeHolder();
+    if (holder === undefined)
+        return;
+    holder.pendingChildBatch.boundaries = [...boundaries];
+}

package/dist/workflow/heartbeat.d.ts

@@ -0,0 +1,15 @@
+/** Fail-closed attempt lease heartbeat. */
+import type { AttemptContext } from "../generated/workflow/v1/runtime_pb.js";
+import { type WorkflowClient } from "./client.js";
+export declare class AttemptHeartbeat {
+    private readonly attempt;
+    private readonly client;
+    private timer;
+    private stopped;
+    private inFlight;
+    constructor(attempt: AttemptContext, client: WorkflowClient);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private request;
+}
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/workflow/heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../src/workflow/heartbeat.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAK3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAI7E,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAUvE,qBAAa,gBAAgB;IAMzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAoC;gBAGjC,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,cAAc;IAGnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyCtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,OAAO,CAAC,OAAO;CAWhB"}

package/dist/workflow/heartbeat.js

@@ -0,0 +1,78 @@
+/** Fail-closed attempt lease heartbeat. */
+import { create } from "@bufbuild/protobuf";
+import { AttemptHeartbeatRequestSchema } from "../generated/workflow/v1/runtime_pb.js";
+import { WorkflowErrorCode } from "../generated/workflow/v1/common_pb.js";
+import { getLogger } from "../logger.js";
+import { heartbeatIntervalMs } from "./attempt.js";
+import { WorkflowClientError } from "./client.js";
+const logger = getLogger("agent_engine_runner_shared.workflow.heartbeat");
+const LEASE_LOST_CODES = new Set([
+    WorkflowErrorCode.STALE_FENCE,
+    WorkflowErrorCode.UNAUTHORIZED,
+    WorkflowErrorCode.NOT_FOUND,
+]);
+export class AttemptHeartbeat {
+    attempt;
+    client;
+    timer = null;
+    stopped = false;
+    inFlight = Promise.resolve();
+    constructor(attempt, client) {
+        this.attempt = attempt;
+        this.client = client;
+    }
+    async start() {
+        if (this.timer !== null) {
+            throw new Error("attempt heartbeat already started");
+        }
+        const request = this.request();
+        try {
+            await this.client.heartbeat(request);
+        }
+        catch (error) {
+            throw new Error("initial durable attempt heartbeat failed", {
+                cause: error,
+            });
+        }
+        const interval = heartbeatIntervalMs(this.attempt.heartbeatIntervalMs);
+        this.timer = setInterval(() => {
+            this.inFlight = this.inFlight.then(async () => {
+                if (this.stopped)
+                    return;
+                try {
+                    await this.client.heartbeat(request);
+                }
+                catch (error) {
+                    if (error instanceof WorkflowClientError &&
+                        LEASE_LOST_CODES.has(error.code)) {
+                        this.stopped = true;
+                        if (this.timer !== null)
+                            clearInterval(this.timer);
+                        logger.error({ err: error, attempt_id: this.attempt.attemptId }, "Durable attempt lease permanently lost");
+                        return;
+                    }
+                    logger.warn({ err: error, attempt_id: this.attempt.attemptId }, "Failed to renew durable attempt lease; retrying");
+                }
+            });
+        }, interval);
+        this.timer.unref();
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer !== null)
+            clearInterval(this.timer);
+        this.timer = null;
+        await this.inFlight;
+    }
+    request() {
+        if (this.attempt.workflowIdentity === undefined) {
+            throw new Error("AttemptContext.workflow_identity is required");
+        }
+        return create(AttemptHeartbeatRequestSchema, {
+            workflowIdentity: this.attempt.workflowIdentity,
+            attemptId: this.attempt.attemptId,
+            fencingToken: this.attempt.fencingToken,
+            ownerId: this.attempt.ownerId,
+        });
+    }
+}

package/dist/workflow/index.d.ts

@@ -0,0 +1,14 @@
+export { attemptStartRequestFromExecute, completeExecutionCommand, finalizeCurrentStepCommand, finalizeCurrentStepSuspensionsCommand, newDurabilityOwnerId, } from "./attempt.js";
+export { ActivityDispatch, ActivityReplay, WorkflowClient, WorkflowClientError, encodeProtoJson, } from "./client.js";
+export type { StartActivityResult } from "./client.js";
+export { DurableActivityDeniedError, DurableActivityInterrupted, ReplayedActivityFailedError, buildActivityCommand, completedOutcome, failedOutcome, runSerialActivity, runStreamingActivity, unwrapActivityOutcome, valueToJson, } from "./activity.js";
+export type { ActivityResolvedHook } from "./activity.js";
+export { UnsupportedChildOperationFanOutError, activityRequiresReconstruction, allocateActivityOrdinal, advanceStepOrdinal, childOperationBoundaryScope, currentAttemptContext, currentOperationPath, currentPendingChildOperationBatch, currentStepOrdinal, interruptedActivities, observedActivityPositions, preallocateActivityOrdinals, preallocateChildOperationOrdinals, recordObservedActivity, recordInterruptedActivity, recordReconstructedActivityInterrupt, runWithAttemptContext, runWithOperationPathResolver, setActivityReconstructionIds, setPendingChildOperationBatch, toolActivityKey, } from "./context.js";
+export type { ChildOperationBoundary, InterruptedActivity, OperationPathResolver, } from "./context.js";
+export { AttemptHeartbeat } from "./heartbeat.js";
+export { DurableMemoryState, validateDurableMemoryIdentity } from "./memory.js";
+export * from "../generated/workflow/v1/activity_pb.js";
+export * from "../generated/workflow/v1/common_pb.js";
+export * from "../generated/workflow/v1/runtime_pb.js";
+export * from "../generated/workflow/v1/state_pb.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,wBAAwB,EACxB,0BAA0B,EAC1B,qCAAqC,EACrC,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC3B,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EACL,oCAAoC,EACpC,8BAA8B,EAC9B,uBAAuB,EACvB,kBAAkB,EAClB,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,EACpB,iCAAiC,EACjC,kBAAkB,EAClB,qBAAqB,EACrB,yBAAyB,EACzB,2BAA2B,EAC3B,iCAAiC,EACjC,sBAAsB,EACtB,yBAAyB,EACzB,oCAAoC,EACpC,qBAAqB,EACrB,4BAA4B,EAC5B,4BAA4B,EAC5B,6BAA6B,EAC7B,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC;AAChF,cAAc,yCAAyC,CAAC;AACxD,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC"}

package/dist/workflow/index.js

@@ -0,0 +1,10 @@
+export { attemptStartRequestFromExecute, completeExecutionCommand, finalizeCurrentStepCommand, finalizeCurrentStepSuspensionsCommand, newDurabilityOwnerId, } from "./attempt.js";
+export { ActivityDispatch, ActivityReplay, WorkflowClient, WorkflowClientError, encodeProtoJson, } from "./client.js";
+export { DurableActivityDeniedError, DurableActivityInterrupted, ReplayedActivityFailedError, buildActivityCommand, completedOutcome, failedOutcome, runSerialActivity, runStreamingActivity, unwrapActivityOutcome, valueToJson, } from "./activity.js";
+export { UnsupportedChildOperationFanOutError, activityRequiresReconstruction, allocateActivityOrdinal, advanceStepOrdinal, childOperationBoundaryScope, currentAttemptContext, currentOperationPath, currentPendingChildOperationBatch, currentStepOrdinal, interruptedActivities, observedActivityPositions, preallocateActivityOrdinals, preallocateChildOperationOrdinals, recordObservedActivity, recordInterruptedActivity, recordReconstructedActivityInterrupt, runWithAttemptContext, runWithOperationPathResolver, setActivityReconstructionIds, setPendingChildOperationBatch, toolActivityKey, } from "./context.js";
+export { AttemptHeartbeat } from "./heartbeat.js";
+export { DurableMemoryState, validateDurableMemoryIdentity } from "./memory.js";
+export * from "../generated/workflow/v1/activity_pb.js";
+export * from "../generated/workflow/v1/common_pb.js";
+export * from "../generated/workflow/v1/runtime_pb.js";
+export * from "../generated/workflow/v1/state_pb.js";

package/dist/workflow/memory.d.ts

@@ -0,0 +1,17 @@
+/** Durable activity synchronization with short-term Memory. */
+import { type ActivityContext, type ActivityMemoryCommand } from "../generated/workflow/v1/activity_pb.js";
+import type { WorkflowIdentity } from "../generated/workflow/v1/common_pb.js";
+export interface WorkflowMemoryClient {
+    ensureMemoryWritten(command: ActivityMemoryCommand): Promise<void>;
+}
+export declare function validateDurableMemoryIdentity(identity: WorkflowIdentity | undefined, userId: string | null | undefined): void;
+/** Own durable Memory projection, delivery, and pending user input. */
+export declare class DurableMemoryState {
+    private pendingUserMessage;
+    private synchronization;
+    constructor(pendingUserMessage?: string | null);
+    synchronizeLlm(client: WorkflowMemoryClient, context: ActivityContext, result: unknown, userId: string | null | undefined): Promise<void>;
+    synchronizeTool(client: WorkflowMemoryClient, context: ActivityContext, result: unknown, userId: string | null | undefined, toolCallId: string | undefined, toolName: string): Promise<void>;
+    private synchronize;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/workflow/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/workflow/memory.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAK/D,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAE3B,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAiB9E,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EACtC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,IAAI,CAYN;AAgGD,uEAAuE;AACvE,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,kBAAkB,CAAgB;IAC1C,OAAO,CAAC,eAAe,CAAoC;gBAE/C,kBAAkB,GAAE,MAAM,GAAG,IAAW;IAIpD,cAAc,CACZ,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,OAAO,CAAC,IAAI,CAAC;IAuChB,eAAe,CACb,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IA+BhB,OAAO,CAAC,WAAW;CAyBpB"}