@gea-ai/agent-sdk 0.1.260910-alpha.0 → 0.1.260910-alpha.2

package/dist/agent-channel-runtime.js

@@ -0,0 +1,623 @@
+import { z } from "zod";
+import { AGENT_CHANNEL_EXECUTION_TIMEOUT_MS, AGENT_CHANNEL_EXECUTION_RECOVERY_GRACE_MS, canonicalAgentChannelJson as canonical, createAgentChannelStableId, agentChannelErrorSchema, agentChannelRunTerminalSchema, agentChannelOperationStatusSchema, } from "@gea-ai/contract/agent-channels";
+import { MAX_CHANNEL_QUEUE_SIZE, agentChannelRuntimeIngressSchema, agentChannelRuntimeResolveSchema, agentChannelRuntimeStartReceiptSchema, agentChannelRuntimeProjectionSchema, agentChannelJournalPageSchema, agentChannelOutboundResultSchema, agentChannelDeliveryEventSchema, } from "@gea-ai/contract/agent-channel-runtime";
+const MAX_PENDING_DELIVERIES = 256;
+const RETRY_DELAYS_MS = [1000, 5000, 30000, 120000];
+const opKey = (id) => `v2:operation:${id}`;
+const json = (body, status = 200) => Response.json(body, { status, headers: { "cache-control": "no-store" } });
+const same = (a, b) => canonical(a) === canonical(b);
+const hostEnvelope = z.discriminatedUnion("ok", [
+    z.object({ ok: z.literal(true), result: z.unknown() }),
+    z.object({ ok: z.literal(false), error: agentChannelErrorSchema }),
+]);
+async function commandBase(config, executionTarget, kind, operationId = "journal") {
+    const addressId = await createAgentChannelStableId("address", config.address);
+    return {
+        protocolVersion: "gea.channel-command/v2",
+        address: config.address,
+        addressId,
+        executionTarget,
+        channelPath: config.channelPath,
+        operationId,
+        commandId: await createAgentChannelStableId(kind, addressId, operationId),
+    };
+}
+async function host(environment, command) {
+    const response = await environment.CHANNEL.fetch(`/v2/commands/${command.kind}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(command),
+    });
+    return hostEnvelope.parse(await response.json());
+}
+/** An accepted operation owns its code target; the address owns only stable session state. */
+export async function handleCustomChannelAddressRequest(request, storage, environment) {
+    const url = new URL(request.url);
+    if (url.pathname === "/v2/capabilities" && request.method === "GET")
+        return json({
+            controlledCallVersion: 1,
+            receiverAuthorizationContextVersion: 1,
+        });
+    if (url.pathname === "/v2/ingress" && request.method === "POST") {
+        const input = agentChannelRuntimeIngressSchema.parse(await request.json());
+        if (input.input.principal.principalId !== input.address.principalId)
+            return json({ error: { code: "channel_principal_mismatch" } }, 403);
+        const fingerprint = await createAgentChannelStableId("input", input.input);
+        const result = await storage.transaction(async (tx) => {
+            request.signal.throwIfAborted();
+            // Native controlled dispatch holds admission authority through this durable transaction.
+            if (input.receiver &&
+                input.receiver.installationId !== input.address.installationId)
+                return { error: "channel_receiver_authority_required" };
+            const existingConfig = await tx.get("v2:configuration");
+            if (existingConfig && !same(existingConfig.address, input.address))
+                return { error: "channel_address_conflict" };
+            const config = existingConfig ?? {
+                address: input.address,
+                sessionId: input.executionTarget.sessionId,
+                stateVersion: input.executionTarget.stateVersion,
+                readTarget: input.executionTarget,
+                channelPath: input.channelPath,
+                ...(input.input.initialState === undefined
+                    ? {}
+                    : { initialState: input.input.initialState }),
+            };
+            if (input.expectedSessionId &&
+                input.expectedSessionId !== config.sessionId)
+                return { error: "channel_execution_target_mismatch" };
+            const existing = await tx.get(opKey(input.input.operationId));
+            if (existing && existing.fingerprint !== fingerprint)
+                return { error: "operation_payload_conflict" };
+            if (!existing) {
+                if (config.stateVersion !== input.executionTarget.stateVersion)
+                    return { error: "channel_state_version_incompatible" };
+                if (config.sessionId !== input.executionTarget.sessionId ||
+                    config.readTarget.workerId !== input.executionTarget.workerId ||
+                    config.channelPath !== input.channelPath)
+                    return { error: "channel_address_conflict" };
+                const queue = (await tx.get("v2:queue")) ?? [];
+                if (queue.length >= MAX_CHANNEL_QUEUE_SIZE)
+                    return { error: "channel_queue_full" };
+                request.signal.throwIfAborted();
+                await tx.put("v2:configuration", {
+                    ...config,
+                    readTarget: input.executionTarget,
+                });
+                await tx.put(opKey(input.input.operationId), {
+                    executionTarget: input.executionTarget,
+                    input: input.input,
+                    fingerprint,
+                    status: "accepted",
+                });
+                await tx.put("v2:queue", [...queue, input.input.operationId]);
+                await tx.setAlarm(Date.now());
+            }
+            return {
+                conversationId: input.address.providerLocalKey,
+                duplicate: Boolean(existing),
+                executionTarget: existing?.executionTarget ?? input.executionTarget,
+                operationId: input.input.operationId,
+                status: "accepted",
+            };
+        });
+        return "error" in result
+            ? json({ error: { code: result.error } }, 409)
+            : json(result, 202);
+    }
+    if (url.pathname === "/v2/session" && request.method === "GET") {
+        const config = await storage.get("v2:configuration");
+        return json(config ? { address: config.address, sessionId: config.sessionId } : null);
+    }
+    if (url.pathname === "/v2/wake" && request.method === "POST") {
+        await storage.setAlarm(Date.now());
+        return json({ accepted: true }, 202);
+    }
+    if (url.pathname === "/v2/deliveries" && request.method === "GET") {
+        const page = z
+            .object({
+            after: z.string().max(128).optional(),
+            limit: z.coerce.number().int().min(1).max(100).default(100),
+        })
+            .parse(Object.fromEntries(url.searchParams));
+        const entries = [
+            ...(await storage.list({ prefix: "v2:outbox:" })),
+        ].filter(([key]) => !page.after || key > page.after);
+        const selected = [];
+        let size = 0;
+        for (const entry of entries) {
+            const bytes = new TextEncoder().encode(JSON.stringify(entry[1])).byteLength;
+            if (selected.length &&
+                (selected.length >= page.limit || size + bytes > 6 * 1024 * 1024))
+                break;
+            selected.push(entry);
+            size += bytes;
+        }
+        return json({
+            deliveries: selected.map(([, row]) => row),
+            nextCursor: selected.length < entries.length ? selected.at(-1)[0] : null,
+            pausedDeliveryId: (await storage.get("v2:delivery-paused")) ?? null,
+            lastError: (await storage.get("v2:last-error")) ?? null,
+        });
+    }
+    const statusMatch = /^\/v2\/status\/([^/]+)$/u.exec(url.pathname);
+    if (statusMatch && request.method === "GET") {
+        const operationId = decodeURIComponent(statusMatch[1]);
+        const operation = await storage.get(opKey(operationId));
+        const config = await storage.get("v2:configuration");
+        if (!operation || !config)
+            return json({ error: { code: "operation_not_found" } }, 404);
+        return json(agentChannelOperationStatusSchema.parse({
+            executionTarget: operation.executionTarget,
+            operationId,
+            status: operation.status,
+            ...(operation.command && operation.status !== "accepted"
+                ? { runId: operation.command.runId }
+                : {}),
+            ...(operation.terminal?.status === "succeeded"
+                ? { reply: operation.terminal.reply }
+                : {}),
+            ...(operation.terminal?.status === "failed"
+                ? { error: operation.terminal.error }
+                : operation.error
+                    ? { error: operation.error }
+                    : {}),
+        }));
+    }
+    const operationMatch = /^\/v2\/operations\/([^/]+)$/u.exec(url.pathname);
+    if (operationMatch && request.method === "GET") {
+        const operation = await storage.get(opKey(decodeURIComponent(operationMatch[1])));
+        const deliveries = await storage.list({ prefix: "v2:outbox:" });
+        return operation
+            ? json({
+                ...operation,
+                deliveries: [...deliveries.values()].filter((row) => row.task.operationId === operation.input.operationId),
+            })
+            : json({ error: { code: "operation_not_found" } }, 404);
+    }
+    if (url.pathname === "/v2/deliveries/resolve" && request.method === "POST") {
+        const input = agentChannelRuntimeResolveSchema.parse(await request.json());
+        const result = await storage.transaction(async (tx) => {
+            const entry = [
+                ...(await tx.list({ prefix: "v2:outbox:" })),
+            ].find(([, row]) => row.task.id === input.deliveryId);
+            if (!entry)
+                return { error: "delivery_not_found" };
+            const [key, row] = entry;
+            if (row.status !== "unknown" && row.status !== "failed")
+                return { error: "delivery_not_resolvable" };
+            const status = input.action === "sent"
+                ? "sent"
+                : input.action === "abandon"
+                    ? "failed"
+                    : "pending";
+            const updated = {
+                ...row,
+                status,
+                nextAttemptAt: Date.now(),
+                resolution: {
+                    actor: input.actor,
+                    reason: input.reason,
+                    action: input.action,
+                    at: Date.now(),
+                },
+            };
+            if (input.action === "retry")
+                await tx.put(key, updated);
+            else {
+                const result = input.action === "sent"
+                    ? {
+                        status: "sent",
+                        receipt: { confirmedBy: input.actor, reason: input.reason },
+                    }
+                    : {
+                        status: "failed",
+                        error: {
+                            code: "delivery_abandoned",
+                            message: input.reason,
+                            retryable: false,
+                        },
+                    };
+                await storeDeliveryResult(tx, key, { ...updated, result }, result);
+            }
+            if ((await tx.get("v2:delivery-paused")) === input.deliveryId)
+                await tx.delete("v2:delivery-paused");
+            await tx.setAlarm(Date.now());
+            return { resolved: true };
+        });
+        return "error" in result
+            ? json({ error: { code: result.error } }, 409)
+            : json(result);
+    }
+    return json({ error: { code: "not_found" } }, 404);
+}
+async function startNext(storage, environment, config) {
+    const queue = (await storage.get("v2:queue")) ?? [];
+    const operationId = queue[0];
+    if (!operationId)
+        return;
+    const operation = await storage.get(opKey(operationId));
+    if (!operation)
+        throw new Error("Channel queue refers to a missing operation.");
+    if (operation.command &&
+        Date.now() <
+            operation.command.executionDeadline +
+                AGENT_CHANNEL_EXECUTION_RECOVERY_GRACE_MS)
+        return;
+    const base = await commandBase(config, operation.executionTarget, "start", operationId);
+    const command = {
+        ...base,
+        kind: "start_run",
+        input: operation.input,
+        executionEpoch: crypto.randomUUID(),
+        executionDeadline: Date.now() + AGENT_CHANNEL_EXECUTION_TIMEOUT_MS,
+        runId: await createAgentChannelStableId("run", base.addressId, operationId),
+        responseMessageId: await createAgentChannelStableId("assistant", base.addressId, operationId),
+        userMessageId: await createAgentChannelStableId("user", base.addressId, operationId),
+    };
+    // The command and its lease exist before dispatch. A process crash is recovered by the next alarm.
+    await storage.put(opKey(operationId), { ...operation, command });
+    const response = await host(environment, command);
+    if (!response.ok) {
+        if (!response.error.retryable)
+            await storage.transaction(async (tx) => {
+                await tx.put(opKey(operationId), {
+                    ...operation,
+                    command,
+                    status: "failed",
+                    error: response.error,
+                });
+                await tx.put("v2:queue", ((await tx.get("v2:queue")) ?? []).filter((id) => id !== operationId));
+            });
+        else
+            await storage.put(opKey(operationId), {
+                ...operation,
+                command: undefined,
+            });
+        return;
+    }
+    const accepted = agentChannelRuntimeStartReceiptSchema.parse(response.result);
+    if (accepted.commandId !== command.commandId ||
+        accepted.executionEpoch !== command.executionEpoch ||
+        accepted.runId !== command.runId)
+        throw new Error("Channel execution receipt does not match its durable command.");
+    await storage.put(opKey(operationId), {
+        ...operation,
+        command,
+        status: "running",
+    });
+}
+async function projectEvents(storage, environment, config) {
+    const after = (await storage.get("v2:checkpoint")) ?? 0;
+    const base = await commandBase(config, config.readTarget, "projection");
+    const read = await host(environment, {
+        ...base,
+        kind: "read_events",
+        after,
+        limit: 64,
+    });
+    if (!read.ok)
+        throw new Error(read.error.message);
+    const page = agentChannelJournalPageSchema.parse(read.result);
+    if (!page.events.length)
+        return;
+    const candidates = await Promise.all(page.events.map(async (event) => {
+        const operation = await storage.get(opKey(event.operationId));
+        if (!operation)
+            throw new Error("Channel event refers to a missing operation.");
+        return {
+            event,
+            input: operation.input,
+            executionTarget: operation.executionTarget,
+        };
+    }));
+    // Preserve journal order and never run another operation's events through this deployment.
+    const executionTarget = candidates[0].executionTarget;
+    const boundary = candidates.findIndex((entry) => !same(entry.executionTarget, executionTarget));
+    const events = candidates
+        .slice(0, boundary < 0 ? candidates.length : boundary)
+        .map(({ event, input }) => ({ event, input }));
+    const state = await storage.get("v2:state");
+    const projected = await host(environment, {
+        ...base,
+        executionTarget,
+        kind: "project_events",
+        events,
+        ...(state === undefined ? {} : { state }),
+        ...(config.initialState === undefined
+            ? {}
+            : { initialState: config.initialState }),
+    });
+    if (!projected.ok)
+        throw new Error(projected.error.message);
+    const result = agentChannelRuntimeProjectionSchema.parse(projected.result);
+    if (result.cursor !== events.at(-1).event.sequence)
+        throw new Error("Channel projection cursor mismatch.");
+    await storage.transaction(async (tx) => {
+        if (((await tx.get("v2:checkpoint")) ?? 0) !== after)
+            return;
+        const staged = new Map();
+        for (const intent of result.intents) {
+            if (!events.some(({ event }) => event.id === intent.eventId &&
+                event.operationId === intent.operationId))
+                throw new Error("Channel output refers to an event outside its projection batch.");
+            const identity = await createAgentChannelStableId("outbox", intent.eventId, intent.key);
+            const old = staged.get(identity) ??
+                (await tx.get(`v2:intent:${identity}`));
+            if (old && !same(old.payload, intent.payload))
+                throw new Error("Channel output key has conflicting payloads.");
+            if (!old)
+                staged.set(identity, intent);
+        }
+        const pending = [
+            ...(await tx.list({ prefix: "v2:outbox:" })).values(),
+        ].filter((row) => row.status !== "sent" && row.status !== "failed").length;
+        if (pending + staged.size > MAX_PENDING_DELIVERIES)
+            throw new Error("Channel pending output limit reached (256).");
+        let sequence = (await tx.get("v2:outbox-sequence")) ?? 0;
+        for (const [identity, intent] of staged) {
+            const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(identity));
+            const bytes = new Uint8Array(digest).slice(0, 16);
+            bytes[6] = (bytes[6] & 15) | 64;
+            bytes[8] = (bytes[8] & 63) | 128;
+            const hex = [...bytes]
+                .map((byte) => byte.toString(16).padStart(2, "0"))
+                .join("");
+            const id = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+            const row = {
+                executionTarget,
+                task: { id, ...intent },
+                attempt: 0,
+                status: "pending",
+                ...(result.idempotencyWindowMs
+                    ? { idempotencyWindowMs: result.idempotencyWindowMs }
+                    : {}),
+            };
+            await tx.put(`v2:outbox:${String(++sequence).padStart(16, "0")}`, row);
+            await tx.put(`v2:intent:${identity}`, { payload: intent.payload });
+        }
+        await tx.put("v2:outbox-sequence", sequence);
+        await tx.put("v2:state", result.state);
+        await tx.put("v2:checkpoint", result.cursor);
+        if (result.cursor >= ((await tx.get("v2:journal-unread")) ?? 0))
+            await tx.delete("v2:journal-unread");
+        const completed = new Set();
+        for (const { event, input } of events) {
+            if (event.type !== "run.succeeded" && event.type !== "run.failed")
+                continue;
+            const operation = await tx.get(opKey(input.operationId));
+            if (!operation)
+                throw new Error("Channel operation disappeared during projection.");
+            const terminal = event.type === "run.succeeded"
+                ? agentChannelRunTerminalSchema.options[0].parse({
+                    status: "succeeded",
+                    ...agentChannelRunTerminalSchema.options[0]
+                        .omit({ status: true })
+                        .parse(event.data),
+                })
+                : agentChannelRunTerminalSchema.options[1].parse({
+                    status: "failed",
+                    ...agentChannelRunTerminalSchema.options[1]
+                        .omit({ status: true })
+                        .parse(event.data),
+                });
+            await tx.put(opKey(input.operationId), {
+                ...operation,
+                status: terminal.status,
+                terminal,
+                attempt: event.attempt,
+            });
+            completed.add(input.operationId);
+        }
+        if (completed.size)
+            await tx.put("v2:queue", ((await tx.get("v2:queue")) ?? []).filter((id) => !completed.has(id)));
+    });
+}
+async function deliverNext(storage, environment, config) {
+    if (await storage.get("v2:delivery-paused"))
+        return;
+    const entry = [
+        ...(await storage.list({ prefix: "v2:outbox:" })),
+    ].find(([, row]) => row.status !== "sent" && row.status !== "failed");
+    if (!entry)
+        return;
+    const [key, previous] = entry;
+    const now = Date.now();
+    let row = previous;
+    if (row.nextAttemptAt && row.nextAttemptAt > now)
+        return;
+    if (row.status === "sending") {
+        if (row.deadline && row.deadline > now)
+            return;
+        row = { ...row, status: "unknown" };
+    }
+    if (row.status === "unknown" &&
+        (!row.idempotencyWindowMs ||
+            !row.firstAttemptAt ||
+            now >= row.firstAttemptAt + row.idempotencyWindowMs ||
+            row.attempt >= 5)) {
+        const result = previous.status === "unknown" && previous.result?.status === "unknown"
+            ? previous.result
+            : {
+                status: "unknown",
+                error: {
+                    code: "delivery_result_unknown",
+                    message: "The provider outcome requires operator resolution.",
+                    retryable: false,
+                },
+            };
+        await storage.transaction((tx) => storeDeliveryResult(tx, key, { ...row, result }, result));
+        await storage.put("v2:delivery-paused", row.task.id);
+        return;
+    }
+    const attempt = row.attempt + 1;
+    const firstAttemptAt = row.firstAttemptAt ?? now;
+    await storage.put(key, {
+        ...row,
+        status: "sending",
+        attempt,
+        firstAttemptAt,
+        deadline: now + 30000,
+    });
+    let result;
+    try {
+        const response = await host(environment, {
+            ...(await commandBase(config, row.executionTarget, "outbound", row.task.operationId)),
+            kind: "outbound",
+            delivery: { ...row.task, attempt, firstAttemptAt },
+        });
+        result = response.ok
+            ? agentChannelOutboundResultSchema.parse(response.result)
+            : {
+                status: response.error.retryable ? "unknown" : "failed",
+                error: response.error,
+            };
+    }
+    catch {
+        result = {
+            status: "unknown",
+            error: {
+                code: "delivery_result_unknown",
+                message: "The outbound invocation ended without a durable receipt.",
+                retryable: false,
+            },
+        };
+    }
+    // A later rejected request cannot establish whether an earlier ambiguous request sent.
+    if (row.status === "unknown" && result.status !== "sent")
+        result = {
+            status: "unknown",
+            error: { ...result.error, retryable: false },
+        };
+    const finalStatus = result.status === "retryable" && attempt >= 5 ? "failed" : result.status;
+    await storage.transaction((tx) => storeDeliveryResult(tx, key, {
+        ...row,
+        status: finalStatus,
+        attempt,
+        firstAttemptAt,
+        result,
+        nextAttemptAt: Date.now() +
+            (result.status === "retryable"
+                ? (result.retryAfterMs ??
+                    RETRY_DELAYS_MS[Math.min(attempt - 1, 3)])
+                : 1000),
+    }, result));
+    if (result.status === "unknown" &&
+        (!row.idempotencyWindowMs ||
+            Date.now() >= firstAttemptAt + row.idempotencyWindowMs ||
+            attempt >= 5))
+        await storage.put("v2:delivery-paused", row.task.id);
+}
+async function storeDeliveryResult(storage, key, row, result) {
+    const operation = await storage.get(opKey(row.task.operationId));
+    if (!operation?.command)
+        throw new Error("Channel delivery has no originating run.");
+    const event = agentChannelDeliveryEventSchema.parse({
+        id: await createAgentChannelStableId("delivery-event", row.task.id, row.attempt, result.status, row.resolution ?? null),
+        operationId: row.task.operationId,
+        runId: operation.command.runId,
+        attempt: operation.attempt ?? 1,
+        type: `delivery.${row.status === "failed" ? "failed" : result.status}`,
+        data: {
+            deliveryId: row.task.id,
+            attempt: row.attempt,
+            result,
+            ...(row.resolution ? { resolution: row.resolution } : {}),
+        },
+    });
+    await storage.put(key, row);
+    await storage.put(`v2:delivery-event:${event.id}`, {
+        executionTarget: row.executionTarget,
+        deliveryId: row.task.id,
+        event,
+    });
+}
+async function flushDeliveryEvents(storage, environment, config) {
+    for (const [key, pending] of await storage.list({
+        prefix: "v2:delivery-event:",
+    })) {
+        const response = await host(environment, {
+            ...(await commandBase(config, pending.executionTarget, "delivery-event", pending.event.operationId)),
+            kind: "record_delivery",
+            ...pending,
+        });
+        if (!response.ok)
+            throw new Error(response.error.message);
+        const { sequence } = z
+            .object({ sequence: z.number().int().positive() })
+            .parse(response.result);
+        await storage.transaction(async (tx) => {
+            await tx.put("v2:journal-unread", Math.max(sequence, (await tx.get("v2:journal-unread")) ?? 0));
+            await tx.delete(key);
+        });
+    }
+}
+/** Input execution, event projection, and delivery advance independently on durable alarms. */
+export async function handleCustomChannelAddressAlarm(storage, environment) {
+    const config = await storage.get("v2:configuration");
+    if (!config)
+        return;
+    const queue = (await storage.get("v2:queue")) ?? [];
+    const pendingEvents = await storage.list({ prefix: "v2:delivery-event:" });
+    const paused = await storage.get("v2:delivery-paused");
+    const pendingDeliveries = [
+        ...(await storage.list({ prefix: "v2:outbox:" })).values(),
+    ].some((row) => row.status !== "sent" && row.status !== "failed");
+    if (!queue.length &&
+        !pendingEvents.size &&
+        !(await storage.get("v2:journal-unread")) &&
+        (!pendingDeliveries || paused)) {
+        await storage.deleteAlarm?.();
+        return;
+    }
+    // Persist recovery before calling the host; clear it after all queues are idle.
+    await storage.setAlarm(Date.now() + 1000);
+    let projectionSucceeded = false;
+    let failed = false;
+    try {
+        await projectEvents(storage, environment, config);
+        projectionSucceeded = true;
+    }
+    catch (error) {
+        failed = true;
+        await storage.put("v2:last-error", {
+            message: error instanceof Error ? error.message : String(error),
+            at: Date.now(),
+        });
+    }
+    const steps = [
+        ...(projectionSucceeded
+            ? [() => startNext(storage, environment, config)]
+            : []),
+        () => deliverNext(storage, environment, config),
+        () => flushDeliveryEvents(storage, environment, config),
+    ];
+    for (const step of steps) {
+        try {
+            await step();
+        }
+        catch (error) {
+            // Alarm is the protocol retry boundary; retain diagnostics without replacing valid state.
+            failed = true;
+            await storage.put("v2:last-error", {
+                message: error instanceof Error ? error.message : String(error),
+                at: Date.now(),
+            });
+        }
+    }
+    if (!failed)
+        await storage.delete("v2:last-error");
+    const activeQueue = (await storage.get("v2:queue")) ?? [];
+    const unsentEvents = await storage.list({ prefix: "v2:delivery-event:" });
+    const unread = await storage.get("v2:journal-unread");
+    const blocked = await storage.get("v2:delivery-paused");
+    const outstanding = [
+        ...(await storage.list({ prefix: "v2:outbox:" })).values(),
+    ].filter((row) => row.status !== "sent" && row.status !== "failed");
+    if (!failed &&
+        !activeQueue.length &&
+        !unsentEvents.size &&
+        !unread &&
+        (!outstanding.length || blocked))
+        await storage.deleteAlarm?.();
+}
+//# sourceMappingURL=agent-channel-runtime.js.map