@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/types/tools.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Tool Policy Types
+ *
+ * Types and definitions for tool/action filtering and permissions in elizaOS.
+ *
+ * @module tools
+ */
+export type { ToolPolicyConfig, ToolProfileId } from "./channel-config";
+import type { ToolPolicyConfig, ToolProfileId } from "./channel-config";
+/**
+ * Canonical tool name aliases for backward compatibility.
+ * Maps legacy names to canonical names.
+ */
+export declare const TOOL_NAME_ALIASES: Record<string, string>;
+/**
+ * Predefined tool groups for easier policy configuration.
+ * Use "group:<name>" syntax in policy configs (e.g., "group:fs").
+ */
+export declare const TOOL_GROUPS: Record<string, string[]>;
+/**
+ * Predefined tool profiles with default allow/deny policies.
+ */
+export declare const TOOL_PROFILES: Record<ToolProfileId, ToolPolicyConfig>;
+/**
+ * Plugin tool groups for dynamic tool resolution.
+ */
+export interface PluginToolGroups {
+    /** All tool names from plugins */
+    all: string[];
+    /** Tool names organized by plugin ID */
+    byPlugin: Map<string, string[]>;
+}
+/**
+ * Result of allowlist resolution with diagnostics.
+ */
+export interface AllowlistResolution {
+    /** The resolved policy after processing */
+    policy: ToolPolicyConfig | undefined;
+    /** Entries in the allowlist that weren't recognized */
+    unknownAllowlist: string[];
+    /** Whether the allowlist was stripped (contained only plugin tools) */
+    strippedAllowlist: boolean;
+}
+/**
+ * Tool policy evaluation options.
+ */
+export interface ToolPolicyEvaluationOptions {
+    /** The character's tool profile */
+    profile?: ToolProfileId;
+    /** Character-level tool policy overrides */
+    characterPolicy?: ToolPolicyConfig;
+    /** Channel-specific tool policy overrides */
+    channelPolicy?: ToolPolicyConfig;
+    /** Provider-specific tool policy overrides */
+    providerPolicy?: ToolPolicyConfig;
+    /** Plugin tool groups for resolution */
+    pluginGroups?: PluginToolGroups;
+    /** Set of core tool names for validation */
+    coreTools?: Set<string>;
+}
+/**
+ * Tool policy evaluation result.
+ */
+export interface ToolPolicyResult {
+    /** Whether the tool is allowed */
+    allowed: boolean;
+    /** Reason for the decision */
+    reason: string;
+    /** The effective policy after merging */
+    effectivePolicy: ToolPolicyConfig;
+}
+/**
+ * Normalize a tool name to its canonical form.
+ * Handles aliases and case normalization.
+ *
+ * @param name - The tool name to normalize
+ * @returns The canonical tool name
+ */
+export declare function normalizeToolName(name: string): string;
+/**
+ * Normalize a list of tool names.
+ *
+ * @param list - The list of tool names to normalize
+ * @returns Normalized list with empty entries filtered out
+ */
+export declare function normalizeToolList(list?: string[]): string[];
+/**
+ * Expand tool groups in a list to their constituent tools.
+ * Handles both group references (e.g., "group:fs") and individual tools.
+ *
+ * @param list - The list containing tool names and/or group references
+ * @returns Expanded list with all groups resolved to individual tools
+ */
+export declare function expandToolGroups(list?: string[]): string[];
+/**
+ * Resolve a tool profile to its policy configuration.
+ *
+ * @param profile - The profile ID to resolve
+ * @returns The policy configuration, or undefined if profile is invalid
+ */
+export declare function resolveToolProfilePolicy(profile?: string): ToolPolicyConfig | undefined;
+/**
+ * Collect all explicit allow entries from multiple policies.
+ *
+ * @param policies - Array of policies to collect from
+ * @returns Combined allowlist entries
+ */
+export declare function collectExplicitAllowlist(policies: Array<ToolPolicyConfig | undefined>): string[];
+/**
+ * Build plugin tool groups from a list of tools with metadata.
+ *
+ * @param params - Tools and metadata accessor
+ * @returns Plugin tool groups organized by plugin ID
+ */
+export declare function buildPluginToolGroups<T extends {
+    name: string;
+}>(params: {
+    tools: T[];
+    toolMeta: (tool: T) => {
+        pluginId: string;
+    } | undefined;
+}): PluginToolGroups;
+/**
+ * Expand plugin group references in a list.
+ *
+ * @param list - The list containing potential plugin group references
+ * @param groups - Plugin tool groups for resolution
+ * @returns Expanded list with plugin groups resolved
+ */
+export declare function expandPluginGroups(list: string[] | undefined, groups: PluginToolGroups): string[] | undefined;
+/**
+ * Expand a policy with plugin group resolution.
+ *
+ * @param policy - The policy to expand
+ * @param groups - Plugin tool groups for resolution
+ * @returns Policy with plugin groups expanded
+ */
+export declare function expandPolicyWithPluginGroups(policy: ToolPolicyConfig | undefined, groups: PluginToolGroups): ToolPolicyConfig | undefined;
+/**
+ * Strip plugin-only allowlist to prevent accidentally disabling core tools.
+ * When an allowlist contains only plugin tools, we remove it to avoid
+ * inadvertently blocking core functionality.
+ *
+ * @param policy - The policy to check
+ * @param groups - Plugin tool groups
+ * @param coreTools - Set of core tool names
+ * @returns Resolution result with diagnostic information
+ */
+export declare function stripPluginOnlyAllowlist(policy: ToolPolicyConfig | undefined, groups: PluginToolGroups, coreTools: Set<string>): AllowlistResolution;
+/**
+ * Merge multiple tool policies into a single effective policy.
+ * Later policies take precedence for conflicts.
+ *
+ * @param policies - Policies to merge in order of precedence
+ * @returns Merged policy
+ */
+export declare function mergeToolPolicies(...policies: Array<ToolPolicyConfig | undefined>): ToolPolicyConfig;
+/**
+ * Check if a tool is allowed by a policy.
+ *
+ * @param toolName - The tool name to check
+ * @param policy - The policy to evaluate against
+ * @returns Whether the tool is allowed
+ */
+export declare function isToolAllowedByPolicy(toolName: string, policy: ToolPolicyConfig | undefined): boolean;
+//# sourceMappingURL=tools.d.ts.map

package/packages/typescript/src/types/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/types/tools.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAExE,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAGpD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CA2DhD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAyBjE,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,kCAAkC;IAClC,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,wCAAwC;IACxC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,2CAA2C;IAC3C,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrC,uDAAuD;IACvD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,uEAAuE;IACvE,iBAAiB,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC3C,mCAAmC;IACnC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,4CAA4C;IAC5C,eAAe,CAAC,EAAE,gBAAgB,CAAC;IACnC,6CAA6C;IAC7C,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,8CAA8C;IAC9C,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAClC,wCAAwC;IACxC,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,4CAA4C;IAC5C,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,eAAe,EAAE,gBAAgB,CAAC;CAClC;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAK3D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAc1D;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,CAAC,EAAE,MAAM,GACd,gBAAgB,GAAG,SAAS,CAgB9B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,KAAK,CAAC,gBAAgB,GAAG,SAAS,CAAC,GAC3C,MAAM,EAAE,CAmBV;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,EAAE;IACzE,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CACxD,GAAG,gBAAgB,CAkBnB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,EAC1B,MAAM,EAAE,gBAAgB,GACtB,MAAM,EAAE,GAAG,SAAS,CAyBtB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,MAAM,EAAE,gBAAgB,GACtB,gBAAgB,GAAG,SAAS,CAQ9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACpB,mBAAmB,CAyCrB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,QAAQ,EAAE,KAAK,CAAC,gBAAgB,GAAG,SAAS,CAAC,GAC9C,gBAAgB,CA0BlB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,gBAAgB,GAAG,SAAS,GAClC,OAAO,CA4BT"}

package/packages/typescript/src/types/tools.js

@@ -0,0 +1,380 @@
+/**
+ * Tool Policy Types
+ *
+ * Types and definitions for tool/action filtering and permissions in elizaOS.
+ *
+ * @module tools
+ */
+/**
+ * Canonical tool name aliases for backward compatibility.
+ * Maps legacy names to canonical names.
+ */
+export const TOOL_NAME_ALIASES = {
+    bash: "exec",
+    "apply-patch": "apply_patch",
+};
+/**
+ * Predefined tool groups for easier policy configuration.
+ * Use "group:<name>" syntax in policy configs (e.g., "group:fs").
+ */
+export const TOOL_GROUPS = {
+    // Memory tools (provided by plugin-scratchpad)
+    "group:memory": [
+        "scratchpad_search",
+        "scratchpad_read",
+        "read_attachment",
+        "remove_from_scratchpad",
+    ],
+    // Web tools
+    "group:web": ["web_search", "web_fetch"],
+    // Basic workspace/file tools
+    "group:fs": ["read", "read_file", "write", "edit", "apply_patch"],
+    // Host/runtime execution tools
+    "group:runtime": ["exec", "process"],
+    // Session management tools
+    "group:sessions": [
+        "sessions_list",
+        "sessions_history",
+        "sessions_send",
+        "sessions_spawn",
+        "session_status",
+    ],
+    // UI helpers
+    "group:ui": ["browser", "canvas"],
+    // Automation + infra
+    "group:automation": ["cron", "gateway"],
+    // Messaging surface
+    "group:messaging": ["message"],
+    // Nodes + device tools
+    "group:nodes": ["nodes"],
+    // All native tools (excludes provider plugins)
+    "group:all": [
+        "browser",
+        "canvas",
+        "nodes",
+        "cron",
+        "message",
+        "gateway",
+        "agents_list",
+        "sessions_list",
+        "sessions_history",
+        "sessions_send",
+        "sessions_spawn",
+        "session_status",
+        "scratchpad_search",
+        "scratchpad_read",
+        "read_attachment",
+        "read_file",
+        "remove_from_scratchpad",
+        "web_search",
+        "web_fetch",
+        "image",
+        "read",
+        "write",
+        "edit",
+        "apply_patch",
+        "exec",
+        "process",
+    ],
+};
+/**
+ * Predefined tool profiles with default allow/deny policies.
+ */
+export const TOOL_PROFILES = {
+    minimal: {
+        allow: ["session_status"],
+    },
+    coding: {
+        allow: [
+            "group:fs",
+            "group:runtime",
+            "group:sessions",
+            "group:memory",
+            "image",
+        ],
+    },
+    messaging: {
+        allow: [
+            "group:messaging",
+            "sessions_list",
+            "sessions_history",
+            "sessions_send",
+            "session_status",
+        ],
+    },
+    full: {
+    // No restrictions - all tools allowed
+    },
+};
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Normalize a tool name to its canonical form.
+ * Handles aliases and case normalization.
+ *
+ * @param name - The tool name to normalize
+ * @returns The canonical tool name
+ */
+export function normalizeToolName(name) {
+    const normalized = name.trim().toLowerCase();
+    return TOOL_NAME_ALIASES[normalized] ?? normalized;
+}
+/**
+ * Normalize a list of tool names.
+ *
+ * @param list - The list of tool names to normalize
+ * @returns Normalized list with empty entries filtered out
+ */
+export function normalizeToolList(list) {
+    if (!list) {
+        return [];
+    }
+    return list.map(normalizeToolName).filter(Boolean);
+}
+/**
+ * Expand tool groups in a list to their constituent tools.
+ * Handles both group references (e.g., "group:fs") and individual tools.
+ *
+ * @param list - The list containing tool names and/or group references
+ * @returns Expanded list with all groups resolved to individual tools
+ */
+export function expandToolGroups(list) {
+    const normalized = normalizeToolList(list);
+    const expanded = [];
+    for (const value of normalized) {
+        const group = TOOL_GROUPS[value];
+        if (group) {
+            expanded.push(...group);
+            continue;
+        }
+        expanded.push(value);
+    }
+    return Array.from(new Set(expanded));
+}
+/**
+ * Resolve a tool profile to its policy configuration.
+ *
+ * @param profile - The profile ID to resolve
+ * @returns The policy configuration, or undefined if profile is invalid
+ */
+export function resolveToolProfilePolicy(profile) {
+    if (!profile) {
+        return undefined;
+    }
+    const resolved = TOOL_PROFILES[profile];
+    if (!resolved) {
+        return undefined;
+    }
+    // Return undefined for 'full' profile (no restrictions)
+    if (!resolved.allow && !resolved.deny) {
+        return undefined;
+    }
+    return {
+        allow: resolved.allow ? [...resolved.allow] : undefined,
+        deny: resolved.deny ? [...resolved.deny] : undefined,
+    };
+}
+/**
+ * Collect all explicit allow entries from multiple policies.
+ *
+ * @param policies - Array of policies to collect from
+ * @returns Combined allowlist entries
+ */
+export function collectExplicitAllowlist(policies) {
+    const entries = [];
+    for (const policy of policies) {
+        if (!policy?.allow) {
+            continue;
+        }
+        for (const value of policy.allow) {
+            if (typeof value !== "string") {
+                continue;
+            }
+            const trimmed = value.trim();
+            if (trimmed) {
+                entries.push(trimmed);
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Build plugin tool groups from a list of tools with metadata.
+ *
+ * @param params - Tools and metadata accessor
+ * @returns Plugin tool groups organized by plugin ID
+ */
+export function buildPluginToolGroups(params) {
+    const all = [];
+    const byPlugin = new Map();
+    for (const tool of params.tools) {
+        const meta = params.toolMeta(tool);
+        if (!meta) {
+            continue;
+        }
+        const name = normalizeToolName(tool.name);
+        all.push(name);
+        const pluginId = meta.pluginId.toLowerCase();
+        const list = byPlugin.get(pluginId) ?? [];
+        list.push(name);
+        byPlugin.set(pluginId, list);
+    }
+    return { all, byPlugin };
+}
+/**
+ * Expand plugin group references in a list.
+ *
+ * @param list - The list containing potential plugin group references
+ * @param groups - Plugin tool groups for resolution
+ * @returns Expanded list with plugin groups resolved
+ */
+export function expandPluginGroups(list, groups) {
+    if (!list || list.length === 0) {
+        return list;
+    }
+    const expanded = [];
+    for (const entry of list) {
+        const normalized = normalizeToolName(entry);
+        if (normalized === "group:plugins") {
+            if (groups.all.length > 0) {
+                expanded.push(...groups.all);
+            }
+            else {
+                expanded.push(normalized);
+            }
+            continue;
+        }
+        const tools = groups.byPlugin.get(normalized);
+        if (tools && tools.length > 0) {
+            expanded.push(...tools);
+            continue;
+        }
+        expanded.push(normalized);
+    }
+    return Array.from(new Set(expanded));
+}
+/**
+ * Expand a policy with plugin group resolution.
+ *
+ * @param policy - The policy to expand
+ * @param groups - Plugin tool groups for resolution
+ * @returns Policy with plugin groups expanded
+ */
+export function expandPolicyWithPluginGroups(policy, groups) {
+    if (!policy) {
+        return undefined;
+    }
+    return {
+        allow: expandPluginGroups(policy.allow, groups),
+        deny: expandPluginGroups(policy.deny, groups),
+    };
+}
+/**
+ * Strip plugin-only allowlist to prevent accidentally disabling core tools.
+ * When an allowlist contains only plugin tools, we remove it to avoid
+ * inadvertently blocking core functionality.
+ *
+ * @param policy - The policy to check
+ * @param groups - Plugin tool groups
+ * @param coreTools - Set of core tool names
+ * @returns Resolution result with diagnostic information
+ */
+export function stripPluginOnlyAllowlist(policy, groups, coreTools) {
+    if (!policy?.allow || policy.allow.length === 0) {
+        return { policy, unknownAllowlist: [], strippedAllowlist: false };
+    }
+    const normalized = normalizeToolList(policy.allow);
+    if (normalized.length === 0) {
+        return { policy, unknownAllowlist: [], strippedAllowlist: false };
+    }
+    const pluginIds = new Set(groups.byPlugin.keys());
+    const pluginTools = new Set(groups.all);
+    const unknownAllowlist = [];
+    let hasCoreEntry = false;
+    for (const entry of normalized) {
+        if (entry === "*") {
+            hasCoreEntry = true;
+            continue;
+        }
+        const isPluginEntry = entry === "group:plugins" ||
+            pluginIds.has(entry) ||
+            pluginTools.has(entry);
+        const expanded = expandToolGroups([entry]);
+        const isCoreEntry = expanded.some((tool) => coreTools.has(tool));
+        if (isCoreEntry) {
+            hasCoreEntry = true;
+        }
+        if (!isCoreEntry && !isPluginEntry) {
+            unknownAllowlist.push(entry);
+        }
+    }
+    const strippedAllowlist = !hasCoreEntry;
+    return {
+        policy: strippedAllowlist ? { ...policy, allow: undefined } : policy,
+        unknownAllowlist: Array.from(new Set(unknownAllowlist)),
+        strippedAllowlist,
+    };
+}
+/**
+ * Merge multiple tool policies into a single effective policy.
+ * Later policies take precedence for conflicts.
+ *
+ * @param policies - Policies to merge in order of precedence
+ * @returns Merged policy
+ */
+export function mergeToolPolicies(...policies) {
+    const result = {};
+    for (const policy of policies) {
+        if (!policy)
+            continue;
+        if (policy.allow !== undefined) {
+            // If a more specific policy has an allow list, it replaces (not merges)
+            result.allow = [...(policy.allow || [])];
+        }
+        if (policy.deny !== undefined) {
+            // Deny lists are additive - combine them
+            result.deny = [...(result.deny || []), ...(policy.deny || [])];
+        }
+    }
+    // Deduplicate
+    if (result.allow) {
+        result.allow = Array.from(new Set(result.allow));
+    }
+    if (result.deny) {
+        result.deny = Array.from(new Set(result.deny));
+    }
+    return result;
+}
+/**
+ * Check if a tool is allowed by a policy.
+ *
+ * @param toolName - The tool name to check
+ * @param policy - The policy to evaluate against
+ * @returns Whether the tool is allowed
+ */
+export function isToolAllowedByPolicy(toolName, policy) {
+    const normalizedName = normalizeToolName(toolName);
+    // No policy means all tools allowed
+    if (!policy) {
+        return true;
+    }
+    // Check deny list first (deny takes precedence)
+    if (policy.deny && policy.deny.length > 0) {
+        const expandedDeny = expandToolGroups(policy.deny);
+        if (expandedDeny.includes(normalizedName)) {
+            return false;
+        }
+    }
+    // Check allow list
+    if (policy.allow && policy.allow.length > 0) {
+        const expandedAllow = expandToolGroups(policy.allow);
+        // Wildcard allows everything not denied
+        if (expandedAllow.includes("*")) {
+            return true;
+        }
+        return expandedAllow.includes(normalizedName);
+    }
+    // No allow list means all tools allowed (if not denied)
+    return true;
+}

package/packages/typescript/src/types/trigger.d.ts

@@ -0,0 +1,42 @@
+import type { UUID } from "./primitives";
+export declare const TRIGGER_SCHEMA_VERSION: 1;
+export type TriggerType = "interval" | "once" | "cron";
+export type TriggerWakeMode = "inject_now" | "next_autonomy_cycle";
+export type TriggerLastStatus = "success" | "error" | "skipped";
+export type TriggerKind = "text" | "workflow";
+export interface TriggerConfig {
+    version: typeof TRIGGER_SCHEMA_VERSION;
+    triggerId: UUID;
+    displayName: string;
+    instructions: string;
+    triggerType: TriggerType;
+    enabled: boolean;
+    wakeMode: TriggerWakeMode;
+    createdBy: string;
+    timezone?: string;
+    intervalMs?: number;
+    scheduledAtIso?: string;
+    cronExpression?: string;
+    maxRuns?: number;
+    runCount: number;
+    nextRunAtMs?: number;
+    lastRunAtIso?: string;
+    lastStatus?: TriggerLastStatus;
+    lastError?: string;
+    dedupeKey?: string;
+    kind?: TriggerKind;
+    workflowId?: string;
+    workflowName?: string;
+}
+export interface TriggerRunRecord {
+    triggerRunId: UUID;
+    triggerId: UUID;
+    taskId: UUID;
+    startedAt: number;
+    finishedAt: number;
+    status: TriggerLastStatus;
+    error?: string;
+    latencyMs: number;
+    source: "scheduler" | "manual";
+}
+//# sourceMappingURL=trigger.d.ts.map

package/packages/typescript/src/types/trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/types/trigger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,sBAAsB,EAAG,CAAU,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,qBAAqB,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAChE,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,UAAU,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,OAAO,sBAAsB,CAAC;IACvC,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAChC,YAAY,EAAE,IAAI,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,IAAI,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;CAC/B"}

package/packages/typescript/src/types/trigger.js

@@ -0,0 +1 @@
+export const TRIGGER_SCHEMA_VERSION = 1;

package/packages/typescript/src/utils/batch-queue/batch-processor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Stateless execution of a **batch** of work items: each item runs through `process` with a
+ * {@link Semaphore} cap, exponential backoff between attempts, and optional `onExhausted`.
+ *
+ * **Why not push failed items back onto a queue:** Inline retries keep item lifecycle simple and
+ * avoid losing work between ticks; releasing the semaphore between attempts lets other items run.
+ *
+ * Reuses `resolveRetryConfig` / `computeBackoff` from `utils/retry.ts` so delay policy matches
+ * the rest of the runtime.
+ */
+import { type RetryConfig } from "../retry.js";
+export interface BatchItemOutcome<T> {
+    item: T;
+    success: boolean;
+    error?: Error;
+    retryCount: number;
+}
+export interface BatchProcessorOptions<T> {
+    /** Max concurrent `process` calls across the batch. */
+    maxParallel: number;
+    /**
+     * After a failed attempt, re-try up to this many times (embedding-style).
+     * Total attempts = maxRetriesAfterFailure + 1. Default 3 → 4 total tries.
+     *
+     * **Interaction with per-item `_batchMaxAttempts`:** If the item is an object with numeric
+     * `_batchMaxAttempts`, that value is used as total attempts (unless `maxAttemptsCap` applies).
+     */
+    maxRetriesAfterFailure?: number;
+    retryPolicy?: RetryConfig;
+    /**
+     * Upper bound on attempts per item after resolving per-item `maxRetries` and global retry config.
+     * Use for shutdown-style paths where items may carry large `maxRetries` but only one try is wanted.
+     */
+    maxAttemptsCap?: number;
+    process: (item: T) => Promise<void>;
+    onExhausted?: (item: T, error: Error) => void | Promise<void>;
+    shouldRetry?: (item: T, error: Error, attempt: number) => boolean;
+}
+export declare class BatchProcessor<T> {
+    private readonly maxParallel;
+    private readonly defaultMaxAttempts;
+    private readonly maxAttemptsCap?;
+    private readonly policy;
+    private readonly process;
+    private readonly onExhausted?;
+    private readonly shouldRetry;
+    private readonly semaphore;
+    constructor(options: BatchProcessorOptions<T>);
+    processBatch(items: T[]): Promise<BatchItemOutcome<T>[]>;
+    private processOne;
+}
+//# sourceMappingURL=batch-processor.d.ts.map

package/packages/typescript/src/utils/batch-queue/batch-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processor.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/utils/batch-queue/batch-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAGN,KAAK,WAAW,EAGhB,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAClC,IAAI,EAAE,CAAC,CAAC;IACR,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACvC,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;CAClE;AA4CD,qBAAa,cAAc,CAAC,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAGH;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAIf;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAE1B,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;IAuBvC,YAAY,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;YAIhD,UAAU;CAsDxB"}