@agent-native/core 0.220.0 → 0.220.1-beta-embedded-chat-20261025-20261025150325

package/dist/action.d.ts

@@ -23,8 +23,26 @@ export interface ActionAutomationContext {
     triggerName: string;
     policyId?: string;
 }
+export declare const DEFAULT_TOOL_RESULT_CHARS = 50000;
+/**
+ * The most characters of a pretty-printed result the agent keeps for a call:
+ * the action's own limit, else the agent-wide limit, else the default, bounded
+ * by any hard limit. The agent loop and actions that fit their own results
+ * resolve it here so they cannot disagree.
+ */
+export declare function resolveToolMaxResultChars(action: {
+    maxResultChars?: number;
+}, limits?: {
+    maxResultChars?: number;
+    hardMaxResultChars?: number;
+}): number;
 export interface ActionRunContext {
     send?: (event: AgentChatEvent) => void;
+    /**
+     * Result cap the agent loop enforces on this call, from
+     * `resolveToolMaxResultChars`. Absent outside the agent loop.
+     */
+    maxResultChars?: number;
     userEmail?: string;
     /**
      * Request headers for server-only actions that must delegate to an

package/dist/action.js

@@ -48,6 +48,21 @@ export async function recordInvalidActionCall(entry, args, ctx, error) {
     }
     return true;
 }
+export const DEFAULT_TOOL_RESULT_CHARS = 50_000;
+/**
+ * The most characters of a pretty-printed result the agent keeps for a call:
+ * the action's own limit, else the agent-wide limit, else the default, bounded
+ * by any hard limit. The agent loop and actions that fit their own results
+ * resolve it here so they cannot disagree.
+ */
+export function resolveToolMaxResultChars(action, limits) {
+    const configured = action.maxResultChars ??
+        limits?.maxResultChars ??
+        DEFAULT_TOOL_RESULT_CHARS;
+    return typeof limits?.hardMaxResultChars === "number"
+        ? Math.min(configured, limits.hardMaxResultChars)
+        : configured;
+}
 export class ActionContractError extends Error {
     actionContractError = true;
     errorCode;

package/dist/agent/actions/list-model-providers.d.ts

@@ -18,6 +18,12 @@ export interface ModelProviderKey {
     rejectedAt?: number;
     /** The rejection markers couldn't be read, so nobody knows if it works. */
     rejectionUnknown?: true;
+    /** A saved key or endpoint exists but could not be decrypted. */
+    unreadable?: true;
+    /** At least one stored API key name could not be decrypted. */
+    unreadableKey?: true;
+    /** The stored OpenAI-compatible endpoint could not be decrypted. */
+    unreadableEndpoint?: true;
     /**
      * Stored in a legacy `workspace` row: the organization's (`workspace` /
      * orgId) for `scope: "org"`, the pre-organization solo row

package/dist/agent/actions/list-model-providers.js

@@ -2,8 +2,9 @@ import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
 import { AGENT_PROVIDER_CATALOG, } from "../../client/agent-provider-catalog.js";
 import { canManageOrg } from "../../org/permissions.js";
+import { AppSecretDecryptionError } from "../../secrets/errors.js";
 import { secretKeyNames } from "../../secrets/key-aliases.js";
-import { readAppSecrets, } from "../../secrets/storage.js";
+import { readAppSecret, readAppSecrets, } from "../../secrets/storage.js";
 import { readProviderCredentialRejections } from "../../server/credential-provider.js";
 import { isPersonalProviderKeyUseRestricted, readOrgMemberRole, } from "../../server/personal-provider-key-policy.js";
 import { getRequestContext } from "../../server/request-context.js";
@@ -30,6 +31,40 @@ function firstPresent(rows, names) {
     }
     return null;
 }
+async function readScopeSecrets(source, keys) {
+    try {
+        return {
+            rows: await readAppSecrets({ keys, ...source }),
+            unreadableKeys: new Set(),
+        };
+    }
+    catch (error) {
+        if (!(error instanceof AppSecretDecryptionError) ||
+            error.scope !== source.scope ||
+            error.scopeId !== source.scopeId) {
+            throw error;
+        }
+    }
+    const rows = new Map();
+    const unreadableKeys = new Set();
+    await Promise.all(keys.map(async (key) => {
+        try {
+            const row = await readAppSecret({ key, ...source });
+            if (row)
+                rows.set(key, row);
+        }
+        catch (error) {
+            if (error instanceof AppSecretDecryptionError &&
+                error.scope === source.scope &&
+                error.scopeId === source.scopeId) {
+                unreadableKeys.add(key);
+                return;
+            }
+            throw error;
+        }
+    }));
+    return { rows, unreadableKeys };
+}
 /**
  * The stored rows the credential resolver reads for one listing scope, in its
  * precedence order. Legacy `workspace` rows power chats like the first-class
@@ -50,35 +85,70 @@ async function readScopeKeys(scope, scopeId, reveal) {
     const names = providerKeyNames();
     const keys = names.flatMap(({ primary, endpoint }) => endpoint ? [...primary, endpoint] : primary);
     const sources = storedRowsFor(scope, scopeId);
-    const reads = await Promise.all(sources.map((source) => readAppSecrets({ keys, ...source })));
+    const reads = await Promise.all(sources.map((source) => readScopeSecrets(source, keys)));
     const found = [];
     const endpointProviders = new Set();
     for (const entry of names) {
-        for (const [index, rows] of reads.entries()) {
-            if (entry.endpoint && firstPresent(rows, [entry.endpoint])) {
+        let unreadableEndpointIndex = null;
+        let resolved = false;
+        for (const [index, read] of reads.entries()) {
+            const { rows, unreadableKeys } = read;
+            const endpoint = entry.endpoint
+                ? firstPresent(rows, [entry.endpoint])
+                : null;
+            const unreadablePrimary = entry.primary.some((key) => unreadableKeys.has(key));
+            const unreadableEndpoint = !!entry.endpoint && unreadableKeys.has(entry.endpoint);
+            if (unreadableEndpoint && unreadableEndpointIndex === null) {
+                unreadableEndpointIndex = index;
+            }
+            if (endpoint || unreadableEndpoint) {
                 endpointProviders.add(entry.option.id);
             }
             const row = firstPresent(rows, entry.primary);
-            if (!row)
-                continue;
+            if (row) {
+                found.push({
+                    names: entry,
+                    row,
+                    endpoint,
+                    legacy: sources[index].scope === "workspace",
+                    unreadableKey: unreadablePrimary,
+                    unreadableEndpoint: unreadableEndpoint || unreadableEndpointIndex !== null,
+                });
+                resolved = true;
+                break;
+            }
+            if (unreadablePrimary) {
+                found.push({
+                    names: entry,
+                    row: null,
+                    endpoint: null,
+                    legacy: sources[index].scope === "workspace",
+                    unreadableKey: true,
+                    unreadableEndpoint: unreadableEndpointIndex !== null,
+                });
+                resolved = true;
+                break;
+            }
+        }
+        if (!resolved && unreadableEndpointIndex !== null) {
             found.push({
                 names: entry,
-                row,
-                endpoint: entry.endpoint ? firstPresent(rows, [entry.endpoint]) : null,
-                legacy: sources[index].scope === "workspace",
+                row: null,
+                endpoint: null,
+                legacy: sources[unreadableEndpointIndex].scope === "workspace",
+                unreadableKey: false,
+                unreadableEndpoint: true,
             });
-            break;
         }
     }
     // Markers are fingerprinted with the canonical key name, the one the
     // runtime records a rejection under, whichever alias the value is stored as.
-    const checkable = found.filter(({ names }) => names.option.id !== "ollama");
+    const checkable = found.flatMap(({ names, row }) => names.option.id !== "ollama" && row
+        ? [{ key: names.option.key, value: row.value }]
+        : []);
     let rejections;
     try {
-        rejections = await readProviderCredentialRejections(checkable.map(({ names, row }) => ({
-            key: names.option.key,
-            value: row.value,
-        })));
+        rejections = await readProviderCredentialRejections(checkable);
     }
     catch (error) {
         console.warn("[list-model-providers] could not read rejection markers", {
@@ -87,28 +157,41 @@ async function readScopeKeys(scope, scopeId, reveal) {
         rejections = null;
     }
     const result = new Map();
-    for (const { names: entry, row, endpoint, legacy } of found) {
+    for (const { names: entry, row, endpoint, legacy, unreadableKey, unreadableEndpoint, } of found) {
         const id = entry.option.id;
         const isOllama = id === "ollama";
-        const rejection = !isOllama && rejections ? rejections.get(entry.option.key) : undefined;
+        const rejection = !isOllama && row && rejections
+            ? rejections.get(entry.option.key)
+            : undefined;
         result.set(id, {
             scope,
-            ...(reveal
+            ...(row && reveal
                 ? {
                     ...(isOllama ? { endpoint: row.value } : { masked: row.last4 }),
                     ...(endpoint?.value ? { endpoint: endpoint.value } : {}),
                 }
                 : {}),
-            updatedAt: row.updatedAt || null,
+            updatedAt: row?.updatedAt || null,
+            ...(unreadableKey || unreadableEndpoint
+                ? {
+                    unreadable: true,
+                    ...(unreadableKey ? { unreadableKey: true } : {}),
+                    ...(unreadableEndpoint
+                        ? { unreadableEndpoint: true }
+                        : {}),
+                }
+                : {}),
             ...(rejection ? { rejectedAt: rejection.at } : {}),
-            ...(!isOllama && !rejections ? { rejectionUnknown: true } : {}),
+            ...(!isOllama && row && !rejections
+                ? { rejectionUnknown: true }
+                : {}),
             ...(legacy ? { legacyWorkspaceRow: true } : {}),
         });
     }
     return { keys: result, endpointProviders };
 }
 export default defineAction({
-    description: "List the model providers on Settings › Model: for each provider (OpenRouter, Ollama, Anthropic, OpenAI, Google Gemini, Groq, Mistral, Cohere), the organization's key and the caller's personal key, masked, with the endpoint URL saved for Ollama or an OpenAI-compatible gateway and when the provider rejected the key (rejectedAt: chats that use it stop until someone replaces it). Members see only that an organization key exists, not its mask. A key in a legacy workspace row (the organization's, or the caller's pre-organization solo row) lists at the scope chats resolve it as, marked legacyWorkspaceRow; removing the provider at that scope deletes it. Also returns whether the caller can manage organization providers, whether personal API keys are restricted for them (their personal keys are then stored but unused), and the stored default model. Builder.io connections come from the Builder.io status, not here. Never returns a key value. Related: get-provider-models and manage-provider-models (which models each provider shows), manage-agent-engine (the default model), manage-provider-key-policy (Restrict personal API keys), preview-secret-removal (what removing a key stops).",
+    description: "List the model providers on Settings › Model: for each provider (OpenRouter, Ollama, Anthropic, OpenAI, Google Gemini, Groq, Mistral, Cohere), the organization's key and the caller's personal key, masked, with the endpoint URL saved for Ollama or an OpenAI-compatible gateway and when the provider rejected the key (rejectedAt: chats that use it stop until someone replaces it). A key entry marked unreadable means saved provider data could not be decrypted; unreadableKey and unreadableEndpoint identify which value. Owners and admins can replace or clear the unreadable value from the row. Members see only that an organization key exists, not its mask. A key in a legacy workspace row (the organization's, or the caller's pre-organization solo row) lists at the scope chats resolve it as, marked legacyWorkspaceRow; removing the provider at that scope deletes it. Also returns whether the caller can manage organization providers, whether personal API keys are restricted for them (their personal keys are then stored but unused), and the stored default model. Builder.io connections come from the Builder.io status, not here. Never returns a key value. Related: get-provider-models and manage-provider-models (which models each provider shows), manage-agent-engine (the default model), manage-provider-key-policy (Restrict personal API keys), preview-secret-removal (what removing a key stops).",
     schema: z.object({}),
     http: { method: "GET" },
     readOnly: true,

package/dist/agent/harness/background.js

@@ -1,8 +1,8 @@
 import { redactArgsToValue, redactTextToSummary } from "../../audit/redact.js";
 import { abortRunDurably } from "../run-manager.js";
 import { getRunEventsSince } from "../run-store.js";
-import { resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopLiveAgentHarnessSession, } from "./lifecycle.js";
-import { getAgentHarnessSessionByRunId, listAgentHarnessSessions, markAgentHarnessSessionStopped, } from "./store.js";
+import { resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopAndPersistAgentHarnessSession, } from "./lifecycle.js";
+import { getAgentHarnessSessionByRunId, listAgentHarnessSessionEvents, listAgentHarnessSessions, } from "./store.js";
 export function createAgentHarnessBackgroundAgentController(scope = { ownerEmail: null }) {
     return {
         list: (options) => listAgentHarnessBackgroundRuns({
@@ -47,11 +47,35 @@ export async function listAgentHarnessBackgroundTranscriptEvents(runId, options
     if (!session?.runId)
         return [];
     const events = await getRunEventsSince(session.runId, 0);
-    return events
+    const runTranscript = events
         .map((event) => parseRunEvent(event))
         .filter((event) => Boolean(event))
-        .map((event) => toAgentHarnessBackgroundTranscriptEvent(session, event))
-        .filter((event) => Boolean(event));
+        .map(({ runEvent, eventAt, transcriptOrder }) => ({
+        transcriptOrder,
+        sourceRank: 0,
+        sourceSeq: runEvent.seq,
+        event: toAgentHarnessBackgroundTranscriptEvent(session, runEvent, eventAt),
+    }))
+        .filter((entry) => Boolean(entry.event));
+    const sessionTranscript = (await listAgentHarnessSessionEvents(session.id))
+        .map((event) => ({
+        transcriptOrder: event.transcriptOrder,
+        sourceRank: 1,
+        sourceSeq: event.seq,
+        event: toAgentHarnessBackgroundSessionTranscriptEvent(session, event),
+    }))
+        .filter((entry) => Boolean(entry.event));
+    return assignCanonicalTranscriptSequence([...runTranscript, ...sessionTranscript]
+        .sort(compareTranscriptOrder)
+        .map(({ event, transcriptOrder }) => transcriptOrder === null
+        ? {
+            ...event,
+            metadata: {
+                ...(event.metadata ?? {}),
+                transcriptOrderFallback: "legacy_source_order",
+            },
+        }
+        : event));
 }
 export async function stopAgentHarnessBackgroundRun(runId, options = {
     ownerEmail: null,
@@ -64,6 +88,7 @@ export async function stopAgentHarnessBackgroundRun(runId, options = {
         return missingHarnessRunResult(runId);
     }
     const failures = [];
+    let stoppedSession = session;
     if (session.runId) {
         try {
             await abortRunDurably(session.runId, "user", { allowNotStarted: true });
@@ -73,16 +98,16 @@ export async function stopAgentHarnessBackgroundRun(runId, options = {
         }
     }
     try {
-        await stopLiveAgentHarnessSession({
+        const stopped = await stopAndPersistAgentHarnessSession({
             sessionId: session.id,
             scope: options,
+            status: failures.length > 0 ? "errored" : "stopped",
         });
-    }
-    catch (error) {
-        failures.push(error);
-    }
-    try {
-        await markAgentHarnessSessionStopped(session.id, failures.length > 0 ? "errored" : "stopped");
+        stoppedSession = stopped ?? {
+            ...session,
+            status: "stopped",
+            stoppedAt: Date.now(),
+        };
     }
     catch (error) {
         failures.push(error);
@@ -95,11 +120,7 @@ export async function stopAgentHarnessBackgroundRun(runId, options = {
     return {
         ok: true,
         runId,
-        run: toAgentHarnessBackgroundRun({
-            ...session,
-            status: "stopped",
-            stoppedAt: Date.now(),
-        }),
+        run: toAgentHarnessBackgroundRun(stoppedSession),
     };
 }
 function toAgentHarnessBackgroundRun(session) {
@@ -144,37 +165,84 @@ function toAgentHarnessBackgroundRun(session) {
             status: session.status,
             pendingApproval: session.pendingApproval,
             workspaceRef: session.workspaceRef,
+            followUpOutcome: session.followUpOutcome,
         },
     };
 }
-function toAgentHarnessBackgroundTranscriptEvent(session, runEvent) {
-    const summary = summarizeAgentChatEvent(runEvent.event);
+function toAgentHarnessBackgroundTranscriptEvent(session, runEvent, eventAt) {
+    return toAgentHarnessTranscriptEvent({
+        session,
+        event: runEvent.event,
+        eventId: `${session.runId ?? session.id}:${runEvent.seq}`,
+        seq: runEvent.seq,
+        createdAt: eventAt ?? session.createdAt,
+        sourceRecordType: "agent-harness-run-event",
+        ...(eventAt === null
+            ? { metadata: { createdAtFallback: "session-created-at" } }
+            : {}),
+    });
+}
+function toAgentHarnessBackgroundSessionTranscriptEvent(session, sessionEvent) {
+    const runId = session.runId ?? session.id;
+    const eventId = `${runId}:operation:${sessionEvent.operationId}:${sessionEvent.seq}`;
+    return toAgentHarnessTranscriptEvent({
+        session,
+        event: sessionEvent.event,
+        eventId,
+        seq: sessionEvent.seq,
+        createdAt: sessionEvent.eventAt,
+        sourceRecordType: "agent-harness-session-event",
+        operationId: sessionEvent.operationId,
+    });
+}
+function toAgentHarnessTranscriptEvent(input) {
+    const { session } = input;
+    const summary = summarizeAgentChatEvent(input.event);
     if (!summary)
         return null;
-    const eventId = `${session.runId ?? session.id}:${runEvent.seq}`;
+    const runId = session.runId ?? session.id;
     return {
         schemaVersion: 1,
-        id: eventId,
-        runId: session.runId ?? session.id,
+        id: input.eventId,
+        runId,
         kind: summary.kind,
         source: "agent-harness",
         sourceRecord: {
-            type: "agent-harness-run-event",
-            id: eventId,
-            seq: runEvent.seq,
+            type: input.sourceRecordType,
+            id: input.eventId,
+            seq: input.seq,
+            ...(input.operationId ? { operationId: input.operationId } : {}),
         },
         message: summary.message,
-        createdAt: new Date(session.updatedAt).toISOString(),
+        createdAt: new Date(input.createdAt).toISOString(),
         metadata: {
             ...(summary.metadata ?? {}),
-            seq: runEvent.seq,
+            ...(input.metadata ?? {}),
+            seq: input.seq,
             harnessName: session.harnessName,
             sessionId: session.id,
+            ...(input.operationId ? { operationId: input.operationId } : {}),
         },
     };
 }
+function assignCanonicalTranscriptSequence(events) {
+    return events.map((event, seq) => {
+        const sourceSeq = event.sourceRecord.seq;
+        return {
+            ...event,
+            sourceRecord: { ...event.sourceRecord, seq },
+            metadata: {
+                ...(event.metadata ?? {}),
+                seq,
+                ...(sourceSeq === undefined ? {} : { sourceSeq }),
+            },
+        };
+    });
+}
 function summarizeAgentChatEvent(event) {
     switch (event.type) {
+        case "user_input":
+            return { kind: "user", message: event.text };
         case "text":
             return { kind: "note", message: event.text };
         case "thinking":
@@ -233,19 +301,40 @@ function summarizeAgentChatEvent(event) {
 function parseRunEvent(row) {
     try {
         const event = JSON.parse(row.eventData);
-        return { seq: Number(row.seq), event };
+        const eventAt = typeof row.eventAt === "number" && Number.isFinite(row.eventAt)
+            ? row.eventAt
+            : null;
+        const transcriptOrder = typeof row.transcriptOrder === "number" &&
+            Number.isFinite(row.transcriptOrder)
+            ? row.transcriptOrder
+            : null;
+        return {
+            runEvent: { seq: Number(row.seq), event },
+            eventAt,
+            transcriptOrder,
+        };
     }
     catch {
         return null;
     }
 }
+function compareTranscriptOrder(left, right) {
+    if (left.transcriptOrder != null && right.transcriptOrder != null) {
+        return left.transcriptOrder - right.transcriptOrder;
+    }
+    if (left.transcriptOrder == null && right.transcriptOrder != null)
+        return -1;
+    if (left.transcriptOrder != null && right.transcriptOrder == null)
+        return 1;
+    return left.sourceRank - right.sourceRank || left.sourceSeq - right.sourceSeq;
+}
 function backgroundStatus(status, needsApproval) {
+    if (needsApproval)
+        return "needs-approval";
     if (status === "running")
         return "running";
     if (status === "errored")
         return "errored";
-    if (needsApproval)
-        return "needs-approval";
     if (status === "idle")
         return "paused";
     if (status === "stopped" || status === "destroyed")

package/dist/agent/harness/index.d.ts

@@ -3,7 +3,7 @@ export { agentHarnessEventToAgentChatEvents, stringifyResult as stringifyAgentHa
 export { getAgentHarnessEntry, isAgentHarnessPackageInstalled, listAgentHarnesses, registerAgentHarness, resolveAgentHarness, type AgentHarnessEntry, } from "./registry.js";
 export { ensureAgentHarnessSessionTables, getAgentHarnessSession, getAgentHarnessSessionByRunId, getLatestAgentHarnessSessionForThread, listAgentHarnessSessions, markAgentHarnessSessionStopped, saveAgentHarnessSession, updateAgentHarnessSession, type AgentHarnessSessionStatus, type SaveAgentHarnessSessionInput, type StoredAgentHarnessSession, } from "./store.js";
 export { sendAgentHarnessEvent, startAgentHarnessRun, type StartAgentHarnessRunOptions, } from "./runner.js";
-export { registerLiveAgentHarnessSession, releaseLiveAgentHarnessSession, resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopLiveAgentHarnessSession, sweepExpiredAgentHarnessSessions, type AgentHarnessLifecycleErrorCode, type AgentHarnessLifecycleResult, type AgentHarnessOwnerScope, } from "./lifecycle.js";
+export { registerLiveAgentHarnessSession, releaseLiveAgentHarnessSession, resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopLiveAgentHarnessSession, sweepExpiredAgentHarnessApprovalResolutions, sweepExpiredAgentHarnessSessions, type AgentHarnessLifecycleErrorCode, type AgentHarnessLifecycleResult, type AgentHarnessOwnerScope, } from "./lifecycle.js";
 export { aiSdkHarnessPartToEvents, createAiSdkHarnessAdapter, type AiSdkHarnessAdapterOptions, type AiSdkHarnessRuntime, } from "./ai-sdk-adapter.js";
 export { ACP_PACKAGE, acpAutoPermissionDecision, acpContentBlockToText, acpFileChangeEventsFromToolContent, acpUpdateToHarnessEvents, buildAcpPromptBlocks, createAcpHarnessAdapter, resolveAcpWorkspacePath, selectAcpPermissionOption, type AcpHarnessAdapterOptions, type AcpSessionUpdate, } from "./acp-adapter.js";
 export { BUILTIN_ACP_PRESETS, registerBuiltinAcpHarnesses, } from "./acp-builtin.js";

package/dist/agent/harness/index.js

@@ -2,7 +2,7 @@ export { agentHarnessEventToAgentChatEvents, stringifyResult as stringifyAgentHa
 export { getAgentHarnessEntry, isAgentHarnessPackageInstalled, listAgentHarnesses, registerAgentHarness, resolveAgentHarness, } from "./registry.js";
 export { ensureAgentHarnessSessionTables, getAgentHarnessSession, getAgentHarnessSessionByRunId, getLatestAgentHarnessSessionForThread, listAgentHarnessSessions, markAgentHarnessSessionStopped, saveAgentHarnessSession, updateAgentHarnessSession, } from "./store.js";
 export { sendAgentHarnessEvent, startAgentHarnessRun, } from "./runner.js";
-export { registerLiveAgentHarnessSession, releaseLiveAgentHarnessSession, resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopLiveAgentHarnessSession, sweepExpiredAgentHarnessSessions, } from "./lifecycle.js";
+export { registerLiveAgentHarnessSession, releaseLiveAgentHarnessSession, resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopLiveAgentHarnessSession, sweepExpiredAgentHarnessApprovalResolutions, sweepExpiredAgentHarnessSessions, } from "./lifecycle.js";
 export { aiSdkHarnessPartToEvents, createAiSdkHarnessAdapter, } from "./ai-sdk-adapter.js";
 export { ACP_PACKAGE, acpAutoPermissionDecision, acpContentBlockToText, acpFileChangeEventsFromToolContent, acpUpdateToHarnessEvents, buildAcpPromptBlocks, createAcpHarnessAdapter, resolveAcpWorkspacePath, selectAcpPermissionOption, } from "./acp-adapter.js";
 export { BUILTIN_ACP_PRESETS, registerBuiltinAcpHarnesses, } from "./acp-builtin.js";

package/dist/agent/harness/lifecycle.d.ts

@@ -22,7 +22,10 @@ export declare function registerLiveAgentHarnessSession(input: {
     createSession?: AgentHarnessCreateSessionOptions;
     ownerEmail?: string | null;
     orgId?: string | null;
+    generation: number;
 }): void;
+export declare function refreshLiveAgentHarnessSessionGeneration(sessionId: string, session: AgentHarnessSession, generation: number): void;
+export declare function getLiveAgentHarnessSessionGeneration(sessionId: string, session: AgentHarnessSession): number | null;
 export declare function releaseLiveAgentHarnessSession(sessionId: string, session?: AgentHarnessSession): void;
 export declare function resolveAgentHarnessApproval(input: {
     runId: string;
@@ -41,4 +44,17 @@ export declare function stopLiveAgentHarnessSession(input: {
     sessionId: string;
     scope: AgentHarnessOwnerScope;
 }): Promise<boolean>;
+export declare function stopAndPersistAgentHarnessSession(input: {
+    sessionId: string;
+    scope: AgentHarnessOwnerScope;
+    status: "stopped" | "errored";
+}): Promise<StoredAgentHarnessSession | null>;
 export declare function sweepExpiredAgentHarnessSessions(now?: number): Promise<number>;
+export declare function sweepExpiredAgentHarnessFollowUps(limit?: number): Promise<{
+    recovered: number;
+    truncated: boolean;
+}>;
+export declare function sweepExpiredAgentHarnessApprovalResolutions(limit?: number): Promise<{
+    recovered: number;
+    truncated: boolean;
+}>;