};

}

export function pickResolvedGatewayHost(beacon: GatewayBonjourBeacon): string | null {

return resolveGatewayDiscoveryEndpoint(beacon)?.host ?? null;

}

export function pickResolvedGatewayPort(beacon: GatewayBonjourBeacon): number | null {

return resolveGatewayDiscoveryEndpoint(beacon)?.port ?? null;

}

type GatewayBonjourDiscoverOpts = {

timeoutMs?: number;

domains?: string[];

return false;

}

/**

* Get the overflow patterns for testing purposes.

*/

export function getOverflowPatterns(): RegExp[] {

return [...OVERFLOW_PATTERNS];

}

}

}

/** Encodes versioned assistant text metadata stored alongside streamed text blocks. */

export function encodeAssistantTextSignature(params: {

id: string;

phase?: AssistantPhase;

}): string {

return JSON.stringify({

v: 1,

id: params.id,

...(params.phase ? { phase: params.phase } : {}),

});

}

/** Resolves a message phase only when the top-level phase or all explicit blocks agree. */

export function resolveAssistantMessagePhase(message: unknown): AssistantPhase | undefined {

if (!message || typeof message !== "object") {

};

}

export function resolveSkillRootScanLimit(config?: OpenClawConfig): number {

return config?.skills?.limits?.maxCandidatesPerRoot ?? DEFAULT_MAX_CANDIDATES_PER_ROOT;

}

function listChildDirectories(

dir: string,

opts?: {

});

}

export function filterWorkspaceSkillEntries(

entries: SkillEntry[],

config?: OpenClawConfig,

): SkillEntry[] {

return filterSkillEntries(entries, config);

}

export function filterWorkspaceSkillEntriesWithOptions(

entries: SkillEntry[],

opts?: {

isParentFlowLinkError,

linkTaskToFlowById,

listTasksForFlowId,

markTaskLostById,

markTaskRunningByRunId,

finalizeTaskRunByRunId as finalizeTaskRunByRunIdInRegistry,

recordTaskProgressByRunId,

});

}

export function markTaskRunLostById(params: {

taskId: string;

endedAt: number;

lastEventAt?: number;

error?: string;

cleanupAfter?: number;

}) {

return markTaskLostById(params);

}

export function setDetachedTaskDeliveryStatusByRunId(params: {

runId: string;

runtime?: TaskRuntime;

});

}

export function retryBlockedFlowAsRunningTaskRun(

params: Omit<RetryBlockedFlowParams, "status">,

): RetryBlockedFlowResult {

return retryBlockedFlowTask({

...params,

status: "running",

});

}

type CancelFlowResult = {

found: boolean;

cancelled: boolean;

configuredRuntimeAuthoritative = options.runtimeAuthoritative;

}

}

export function getReconciledTaskById(taskId: string): TaskRecord | undefined {

const task = getTaskById(taskId);

return task ? reconcileTaskRecordForOperatorInspection(task) : undefined;

}

.map(({ insertionIndex: _, ...task }) => task);

}

export function findLatestTaskForSessionKey(sessionKey: string): TaskRecord | undefined {

const task = listTasksForSessionKey(sessionKey)[0];

return task ? cloneTaskRecord(task) : undefined;

}

export function listTasksForSessionKey(sessionKey: string): TaskRecord[] {

ensureTaskRegistryReady();

const key = normalizeOptionalString(sessionKey);