* Defaults to fail-open unless explicitly overridden for a hook name.

*/

failurePolicyByHook?: Partial<Record<PluginHookName, HookFailurePolicy>>;

/**

* Optional timeout for void/observation hooks. A timed-out hook is logged and

* the runner continues, but the plugin's underlying work is not cancelled.

*/

voidHookTimeoutMsByHook?: Partial<Record<PluginHookName, number>>;

};

const DEFAULT_VOID_HOOK_TIMEOUT_MS_BY_HOOK: Partial<Record<PluginHookName, number>> = {

agent_end: 30_000,

};

type ModifyingHookPolicy<K extends PluginHookName, TResult> = {

const logger = options.logger;

const catchErrors = options.catchErrors ?? true;

const failurePolicyByHook = options.failurePolicyByHook ?? {};

const voidHookTimeoutMsByHook = {

...DEFAULT_VOID_HOOK_TIMEOUT_MS_BY_HOOK,

...options.voidHookTimeoutMsByHook,

};

const shouldCatchHookErrors = (hookName: PluginHookName): boolean =>

catchErrors && (failurePolicyByHook[hookName] ?? "fail-open") === "fail-open";

return typeof (value as { then?: unknown }).then === "function";

};

const getVoidHookTimeoutMs = (hookName: PluginHookName): number | undefined => {

const timeoutMs = voidHookTimeoutMsByHook[hookName];

if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {

return undefined;

}

return Math.floor(timeoutMs);

};

const withVoidHookTimeout = async <T>(promise: Promise<T>, timeoutMs: number): Promise<T> => {

let timer: ReturnType<typeof setTimeout> | undefined;

const timeout = new Promise<never>((_, reject) => {

timer = setTimeout(() => {

reject(new Error(`timed out after ${timeoutMs}ms`));

}, timeoutMs);

timer.unref?.();

});

try {

return await Promise.race([promise, timeout]);

} finally {

if (timer) {

clearTimeout(timer);

}

}

};

const runSyncHookHandler = <K extends SyncHookName>(

hook: PluginHookRegistration<K>,

event: SyncHookEvent<K>,

const promises = hooks.map(async (hook) => {

try {

await (hook.handler as (event: unknown, ctx: unknown) => Promise<void>)(event, ctx);

const promise = Promise.resolve(

(hook.handler as (event: unknown, ctx: unknown) => Promise<void> | void)(event, ctx),

);

const timeoutMs = getVoidHookTimeoutMs(hookName);

if (timeoutMs) {

await withVoidHookTimeout(promise, timeoutMs);

} else {

await promise;

}

} catch (err) {

handleHookError({ hookName, pluginId: hook.pluginId, error: err });

}