@agent-native/core 0.157.9 → 0.157.11

package/dist/jobs/remote-execution.js

@@ -0,0 +1,287 @@
+import { enqueueRemoteCommand, getRemoteCommand, getRemoteCommandByIdempotencyKey, } from "../integrations/remote-commands-store.js";
+import { getRemoteDeviceForOwner, getRemoteExecutionCapabilities, } from "../integrations/remote-devices-store.js";
+import { organizationResourceOwner, resourceGetByPath, resourcePutIfCurrent, } from "../resources/store.js";
+import { buildJobResourceContent, parseJobResource, } from "./frontmatter.js";
+import { finishAutomationRun, startAutomationRun } from "./run-history.js";
+/** A remote run is allowed to be long-lived, but never indefinitely invisible. */
+export const REMOTE_AUTOMATION_MAX_ACTIVE_MS = 24 * 60 * 60_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function automationName(path) {
+    return path.replace(/^jobs\//, "").replace(/\.md$/, "");
+}
+function remoteRequestId(resource, meta, now) {
+    const runAt = meta.lastRun || now.toISOString();
+    return `remote-automation:${resource.owner}:${resource.path}:${runAt}`.slice(0, 512);
+}
+function assertRemoteHostCanRun(device, meta) {
+    if (device.status !== "active") {
+        throw new Error(`Execution host "${device.label}" is revoked or inactive.`);
+    }
+    const capabilities = getRemoteExecutionCapabilities(device);
+    if (!capabilities)
+        return;
+    if (capabilities.acceptsScheduledWork !== true) {
+        throw new Error(`Execution host "${device.label}" does not accept scheduled work.`);
+    }
+    if (capabilities.workloads?.length &&
+        !capabilities.workloads.includes("scheduled-code")) {
+        throw new Error(`Execution host "${device.label}" does not advertise scheduled-code work.`);
+    }
+    if (meta.executionEngine &&
+        capabilities.engines?.length &&
+        !capabilities.engines.includes(meta.executionEngine)) {
+        throw new Error(`Execution host "${device.label}" does not advertise engine "${meta.executionEngine}".`);
+    }
+}
+async function resolveRemoteHost(input) {
+    const device = await getRemoteDeviceForOwner({
+        id: input.hostId,
+        ownerEmail: input.ownerEmail,
+        orgId: input.orgId,
+    });
+    if (!device) {
+        throw new Error(`Execution host "${input.hostId}" is not paired with this account and organization.`);
+    }
+    return device;
+}
+function remoteRunIdFromCommand(command) {
+    const result = isRecord(command.result) ? command.result : undefined;
+    const nested = isRecord(result?.result) ? result.result : result;
+    const run = isRecord(nested?.run) ? nested.run : undefined;
+    return readString(run?.id, run?.runId);
+}
+/**
+ * Queue one host-targeted automation. The request key is derived from the
+ * persisted start timestamp, so a worker crash between the queue write and
+ * resource bookkeeping cannot create a second remote run.
+ */
+export async function dispatchRemoteAutomation(input) {
+    const now = input.now ?? new Date();
+    const hostId = input.meta.executionHostId?.trim();
+    if (!hostId)
+        throw new Error("A remote automation requires executionHostId.");
+    const device = await resolveRemoteHost({
+        hostId,
+        ownerEmail: input.ownerEmail,
+        orgId: input.orgId,
+    });
+    assertRemoteHostCanRun(device, input.meta);
+    const latest = await resourceGetByPath(input.resource.owner, input.resource.path);
+    if (!latest || latest.id !== input.resource.id) {
+        throw new Error("The automation changed before remote dispatch.");
+    }
+    const parsed = parseJobResource(latest.content);
+    if (parsed.meta.lastStatus !== "running") {
+        throw new Error("The automation is no longer marked as running.");
+    }
+    const requestId = parsed.meta.remoteRequestId ||
+        input.meta.remoteRequestId ||
+        remoteRequestId(latest, parsed.meta, now);
+    let currentResource = latest;
+    let currentMeta = parsed.meta;
+    if (!currentMeta.remoteRequestId) {
+        const withRequest = { ...currentMeta, remoteRequestId: requestId };
+        const claimed = await resourcePutIfCurrent({
+            owner: latest.owner,
+            path: latest.path,
+            content: buildJobResourceContent(withRequest, parsed.body),
+            expectedId: latest.id,
+            expectedUpdatedAt: latest.updatedAt,
+            expectedContent: latest.content,
+        });
+        if (!claimed)
+            throw new Error("The automation changed before remote dispatch.");
+        currentResource = claimed;
+        currentMeta = withRequest;
+    }
+    let automationRunId = input.historyId || currentMeta.remoteAutomationRunId;
+    let createdHistory = false;
+    if (!automationRunId) {
+        try {
+            const historyOwner = input.orgId
+                ? organizationResourceOwner(input.orgId)
+                : input.resource.owner === "__shared__"
+                    ? input.ownerEmail
+                    : input.resource.owner;
+            automationRunId = await startAutomationRun({
+                owner: historyOwner,
+                automation: automationName(input.resource.path),
+                path: input.resource.path,
+                scope: input.orgId ? "organization" : "personal",
+                orgId: input.orgId ?? null,
+                appId: input.appId,
+            });
+            createdHistory = true;
+        }
+        catch (error) {
+            console.warn(`[automations] Could not open remote history for "${input.resource.path}"; queueing without it:`, error);
+            automationRunId = undefined;
+        }
+    }
+    try {
+        const command = await enqueueRemoteCommand({
+            deviceId: device.id,
+            ownerEmail: input.ownerEmail,
+            orgId: input.orgId ?? null,
+            kind: "create-run",
+            idempotencyKey: requestId,
+            platform: "automation",
+            externalThreadId: `automation:${automationName(input.resource.path)}`,
+            params: {
+                prompt: input.prompt,
+                title: input.title,
+                cwd: currentMeta.executionCwd,
+                goalId: `automation:${automationName(input.resource.path)}`,
+                permissionMode: "full-auto",
+                engine: currentMeta.executionEngine,
+                model: currentMeta.model,
+                workload: "scheduled-code",
+                metadata: {
+                    source: "scheduled-automation",
+                    automation: {
+                        name: automationName(input.resource.path),
+                        path: input.resource.path,
+                        runAt: currentMeta.lastRun,
+                    },
+                    ...(automationRunId ? { automationRunId } : {}),
+                },
+            },
+        });
+        const nextMeta = {
+            ...currentMeta,
+            remoteRequestId: requestId,
+            remoteCommandId: command.id,
+            remoteRunId: remoteRunIdFromCommand(command),
+            remoteAutomationRunId: automationRunId,
+            remoteAdvanceSchedule: input.advanceSchedule !== false,
+        };
+        const persisted = await resourcePutIfCurrent({
+            owner: currentResource.owner,
+            path: currentResource.path,
+            content: buildJobResourceContent(nextMeta, parsed.body),
+            expectedId: currentResource.id,
+            expectedUpdatedAt: currentResource.updatedAt,
+            expectedContent: currentResource.content,
+        });
+        if (!persisted) {
+            console.warn(`[automations] Remote command ${command.id} was queued but the automation bookkeeping changed concurrently.`);
+        }
+        return { command, requestId, automationRunId };
+    }
+    catch (error) {
+        if (createdHistory && automationRunId) {
+            await finishAutomationRun(automationRunId, "error", error instanceof Error ? error.message : "Remote dispatch failed.").catch(() => undefined);
+        }
+        throw error;
+    }
+}
+export async function getRemoteAutomationStatus(input) {
+    if (!input.meta.executionHostId)
+        return { state: "not-remote" };
+    if (!input.meta.remoteRequestId) {
+        return {
+            state: "failed",
+            error: "Remote dispatch bookkeeping is missing its request id.",
+        };
+    }
+    const device = await resolveRemoteHost({
+        hostId: input.meta.executionHostId,
+        ownerEmail: input.ownerEmail,
+        orgId: input.orgId,
+    });
+    if (device.status !== "active") {
+        return {
+            state: "failed",
+            error: `Execution host "${device.label}" is revoked or inactive.`,
+        };
+    }
+    const command = input.meta.remoteCommandId
+        ? await getRemoteCommand(input.meta.remoteCommandId)
+        : await getRemoteCommandByIdempotencyKey({
+            deviceId: device.id,
+            idempotencyKey: input.meta.remoteRequestId,
+        });
+    if (command &&
+        (command.deviceId !== device.id ||
+            command.ownerEmail !== input.ownerEmail ||
+            command.orgId !== (input.orgId ?? null))) {
+        return {
+            state: "failed",
+            error: "Remote dispatch bookkeeping failed its host ownership check.",
+        };
+    }
+    if (!command) {
+        const startedAt = input.meta.lastRun
+            ? Date.parse(input.meta.lastRun)
+            : Number.NaN;
+        const age = (input.now ?? new Date()).getTime() - startedAt;
+        return age >= REMOTE_AUTOMATION_MAX_ACTIVE_MS
+            ? {
+                state: "failed",
+                error: "Remote dispatch did not produce a command within 24 hours.",
+            }
+            : { state: "active" };
+    }
+    if (command.status === "failed") {
+        return {
+            state: "failed",
+            command,
+            error: command.errorMessage ?? "The remote command failed.",
+        };
+    }
+    if (command.status !== "completed") {
+        const activeAt = command.updatedAt || command.claimedAt || command.createdAt;
+        const age = (input.now ?? new Date()).getTime() - activeAt;
+        if (Number.isFinite(age) && age >= REMOTE_AUTOMATION_MAX_ACTIVE_MS) {
+            return {
+                state: "failed",
+                command,
+                error: "The remote command remained active for more than 24 hours.",
+            };
+        }
+        return { state: "active", command };
+    }
+    const result = isRecord(command.result) ? command.result : undefined;
+    const nested = isRecord(result?.result) ? result.result : result;
+    if (nested?.ok === false) {
+        return {
+            state: "failed",
+            command,
+            error: command.errorMessage ??
+                readString(nested.error) ??
+                "Remote run failed.",
+        };
+    }
+    const run = isRecord(nested?.run) ? nested.run : undefined;
+    const runStatus = readString(run?.status);
+    if (runStatus === "completed")
+        return { state: "completed", command };
+    if (runStatus === "errored" || runStatus === "paused") {
+        return {
+            state: "failed",
+            command,
+            error: readString(run?.error, run?.errorMessage) ??
+                command.errorMessage ??
+                `Remote run ended with status ${runStatus}.`,
+        };
+    }
+    if (runStatus === "needs-approval")
+        return { state: "active", command };
+    // A future container/Kubernetes adapter may complete a command without
+    // exposing the desktop run shape. Its terminal command is still authoritative.
+    return { state: "completed", command };
+}
+export async function finishRemoteAutomationHistory(meta, state, error) {
+    if (!meta.remoteAutomationRunId)
+        return;
+    await finishAutomationRun(meta.remoteAutomationRunId, state === "completed" ? "success" : "error", error);
+}

package/dist/jobs/scheduler.js

@@ -2,6 +2,7 @@ import { resourceGetByPath, resourceListAllOwners, resourcePutIfCurrent, } from
 import { backgroundRunCutOffReason, isBackgroundAutomationRunActive, resolveBackgroundAutomationIdentity, runBackgroundAutomation, } from "./background-automation-runner.js";
 import { nextOccurrence, isValidCron, describeCron, effectiveTimezone, } from "./cron.js";
 import { buildJobResourceContent, jobBelongsToApp, parseJobResource, } from "./frontmatter.js";
+import { dispatchRemoteAutomation, finishRemoteAutomationHistory, getRemoteAutomationStatus, } from "./remote-execution.js";
 import { claimAutomationRun, finishAutomationRun, getAutomationRun, listAutomationRuns, } from "./run-history.js";
 import { acquireAutomationSchedulerLease, recordAutomationSchedulerHealth, releaseAutomationSchedulerLease, renewAutomationSchedulerLease, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS, } from "./scheduler-health.js";
 // ─── Frontmatter parsing ────────────────────────────────────────────────────
@@ -150,6 +151,12 @@ async function processRecurringJobsWithLease(deps) {
             if (!jobBelongsToApp(meta, deps.appId))
                 continue;
             healthOrgIds.add(meta.orgId ?? null);
+            // A host-targeted run is reconciled from the durable relay command. It
+            // must never fall back to this scheduler after the laptop disconnects.
+            if (meta.lastStatus === "running" && meta.executionHostId) {
+                await reconcileRemoteJob(resource, meta, now);
+                continue;
+            }
             // Skip disabled or missing schedule
             if (!meta.enabled || !meta.schedule)
                 continue;
@@ -341,6 +348,56 @@ function hasRecentIdentityFailure(meta, now) {
         elapsedMs >= 0 &&
         elapsedMs < IDENTITY_FAILURE_RETRY_MS);
 }
+async function reconcileRemoteJob(resource, meta, now) {
+    const ownerEmail = meta.createdBy?.trim() || resource.owner;
+    try {
+        const remote = await getRemoteAutomationStatus({
+            meta,
+            ownerEmail,
+            orgId: meta.orgId,
+            now,
+        });
+        if (remote.state === "active")
+            return;
+        const error = remote.error ??
+            (remote.state === "failed"
+                ? "The remote execution host did not complete this automation."
+                : undefined);
+        await finishRemoteAutomationHistory(meta, remote.state === "completed" ? "completed" : "failed", error).catch((historyError) => {
+            console.warn(`[recurring-jobs] Could not finish remote history for "${resource.path}":`, historyError);
+        });
+        await recordExecutionOutcome(resource, {
+            lastRun: meta.lastRun,
+            lastStatus: remote.state === "completed" ? "success" : "error",
+            lastError: error,
+            remoteRequestId: undefined,
+            remoteCommandId: undefined,
+            remoteRunId: undefined,
+            remoteAutomationRunId: undefined,
+            remoteAdvanceSchedule: undefined,
+            advanceSchedule: meta.remoteAdvanceSchedule !== false,
+        });
+        console.log(`[recurring-jobs] Remote job "${resource.path}" reached ${remote.state}.`);
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.message.slice(0, 200)
+            : "Remote execution host could not be reached.";
+        await finishRemoteAutomationHistory(meta, "failed", message).catch(() => undefined);
+        await recordExecutionOutcome(resource, {
+            lastRun: meta.lastRun,
+            lastStatus: "error",
+            lastError: message,
+            remoteRequestId: undefined,
+            remoteCommandId: undefined,
+            remoteRunId: undefined,
+            remoteAutomationRunId: undefined,
+            remoteAdvanceSchedule: undefined,
+            advanceSchedule: meta.remoteAdvanceSchedule !== false,
+        });
+        console.error(`[recurring-jobs] Remote job "${resource.path}" failed:`, message);
+    }
+}
 async function executeJob(resource, meta, body, deps, now, options = {}) {
     const jobName = resource.path.replace(/^jobs\//, "").replace(/\.md$/, "");
     const jobContext = {
@@ -384,6 +441,50 @@ async function executeJob(resource, meta, body, deps, now, options = {}) {
             error: "The automation changed before the run could start.",
         };
     }
+    const prompt = options.manual
+        ? `[Manual Automation Run: ${jobName}]\nThis run was explicitly started by the automation owner. Execute the following instructions now:\n\n${body}`
+        : `[Recurring Job: ${jobName}]\nSchedule: ${describeCron(meta.schedule, effectiveTimezone(meta.timezone))}\n\nExecute the following job instructions:\n\n${body}`;
+    if (meta.executionHostId) {
+        try {
+            const dispatch = await dispatchRemoteAutomation({
+                resource,
+                meta,
+                body,
+                ownerEmail: jobUserEmail,
+                orgId: jobOrgId,
+                appId: deps.appId,
+                prompt,
+                title: `${options.manual ? "Automation" : "Job"}: ${jobName}`,
+                historyId: options.historyId,
+                advanceSchedule: options.advanceSchedule,
+                now,
+            });
+            console.log(`[recurring-jobs] Job "${jobName}" queued on remote host as ${dispatch.command.id}.`);
+            return { status: "success", runId: dispatch.command.id };
+        }
+        catch (err) {
+            const lastError = err instanceof Error
+                ? err.message.slice(0, 200)
+                : "Remote dispatch failed";
+            const reportedError = `${lastError}. No delivery was confirmed.`;
+            await recordExecutionOutcome(resource, {
+                lastRun: meta.lastRun,
+                lastStatus: "error",
+                lastError: reportedError,
+                remoteRequestId: undefined,
+                remoteCommandId: undefined,
+                remoteRunId: undefined,
+                remoteAutomationRunId: undefined,
+                remoteAdvanceSchedule: undefined,
+                advanceSchedule: options.advanceSchedule,
+            });
+            if (options.historyId) {
+                await finishAutomationRun(options.historyId, "error", reportedError);
+            }
+            console.error(`[recurring-jobs] Job "${jobName}" remote dispatch failed:`, reportedError);
+            return { status: "error", error: reportedError };
+        }
+    }
     const requestContext = meta.originScopeId && meta.deliveryPlatform && meta.deliveryDestination
         ? {
             isIntegrationCaller: true,
@@ -413,9 +514,7 @@ async function executeJob(resource, meta, body, deps, now, options = {}) {
             automation: jobContext,
             ownerEmail: jobUserEmail,
             orgId: jobOrgId,
-            prompt: options.manual
-                ? `[Manual Automation Run: ${jobName}]\nThis run was explicitly started by the automation owner. Execute the following instructions now:\n\n${body}`
-                : `[Recurring Job: ${jobName}]\nSchedule: ${describeCron(meta.schedule, effectiveTimezone(meta.timezone))}\n\nExecute the following job instructions:\n\n${body}`,
+            prompt,
             threadTitle: `${options.manual ? "Automation" : "Job"}: ${jobName} — ${now.toLocaleDateString()}`,
             runIdPrefix: `${options.manual ? "manual" : "job"}-${jobName}`,
             usageLabel: `${options.manual ? "manual-automation" : "recurring-job"}:${jobName}`,

package/dist/jobs/tools.js

@@ -75,7 +75,7 @@ export async function authorizeJobMutation(resourceOwner, meta, appId) {
     return "Only the job's creator (or an org admin) can update or delete it.";
 }
 async function runCreate(args, appId) {
-    const { name, instructions, scope, runAs, model } = args;
+    const { name, instructions, scope, runAs, model, executionHostId, executionEngine, executionCwd, } = args;
     const schedule = typeof args.schedule === "string" && args.schedule.trim()
         ? args.schedule.trim()
         : DEFAULT_AUTOMATION_SCHEDULE;
@@ -136,6 +136,15 @@ async function runCreate(args, appId) {
         ...(typeof model === "string" && model.trim()
             ? { model: model.trim() }
             : {}),
+        ...(typeof executionHostId === "string" && executionHostId.trim()
+            ? { executionHostId: executionHostId.trim() }
+            : {}),
+        ...(typeof executionEngine === "string" && executionEngine.trim()
+            ? { executionEngine: executionEngine.trim() }
+            : {}),
+        ...(typeof executionCwd === "string" && executionCwd.trim()
+            ? { executionCwd: executionCwd.trim() }
+            : {}),
         ...(mcpTools?.length ? { mcpTools } : {}),
     };
     const content = buildJobContent(meta, instructions);
@@ -193,6 +202,9 @@ async function runList(args, appId) {
             deliveryPlatform: meta.deliveryPlatform || null,
             deliveryDestination: meta.deliveryDestination || null,
             model: meta.model || null,
+            executionHostId: meta.executionHostId || null,
+            executionEngine: meta.executionEngine || null,
+            executionCwd: meta.executionCwd || null,
             mcpTools: meta.mcpTools || [],
         };
     }));
@@ -203,7 +215,7 @@ async function runList(args, appId) {
     return JSON.stringify(scheduledJobs, null, 2);
 }
 async function runUpdate(args, appId) {
-    const { name, schedule, instructions, enabled, scope, runAs, model } = args;
+    const { name, schedule, instructions, enabled, scope, runAs, model, executionHostId, executionEngine, executionCwd, } = args;
     const path = `jobs/${name}.md`;
     // Try to find the resource
     let resource = await resourceGetByPath(getSharedOwner(), path);
@@ -260,6 +272,24 @@ async function runUpdate(args, appId) {
     }
     if (typeof model === "string" && model.trim())
         meta.model = model.trim();
+    if (executionHostId !== undefined) {
+        meta.executionHostId =
+            typeof executionHostId === "string" && executionHostId.trim()
+                ? executionHostId.trim()
+                : undefined;
+    }
+    if (executionEngine !== undefined) {
+        meta.executionEngine =
+            typeof executionEngine === "string" && executionEngine.trim()
+                ? executionEngine.trim()
+                : undefined;
+    }
+    if (executionCwd !== undefined) {
+        meta.executionCwd =
+            typeof executionCwd === "string" && executionCwd.trim()
+                ? executionCwd.trim()
+                : undefined;
+    }
     if (args.mcpTools !== undefined) {
         try {
             const mcpTools = normalizeJobMcpTools(args.mcpTools) ?? [];
@@ -284,6 +314,9 @@ async function runUpdate(args, appId) {
         enabled: meta.enabled,
         nextRun: meta.nextRun,
         mcpTools: meta.mcpTools || [],
+        executionHostId: meta.executionHostId || null,
+        executionEngine: meta.executionEngine || null,
+        executionCwd: meta.executionCwd || null,
     });
 }
 async function runDelete(args, appId) {
@@ -326,7 +359,9 @@ Actions:
 
 Cron format is 5 fields: minute hour day-of-month month day-of-week. Common patterns: '0 9 * * *' (daily 9am), '0 9 * * 1-5' (weekdays 9am), '0 * * * *' (every hour), '0 9 * * 1' (Mondays 9am), '*/30 * * * *' (every 30 min).
 
-For jobs that use a connected MCP, pass the exact tool names in mcpTools. This binds only those tools to the background run; OAuth credentials remain in the connector and are resolved for the job's user/org context.`,
+For jobs that use a connected MCP, pass the exact tool names in mcpTools. This binds only those tools to the background run; OAuth credentials remain in the connector and are resolved for the job's user/org context.
+
+To run code-agent work on a paired always-on computer, pass executionHostId (from manage-automations action=list-hosts), and optionally executionEngine and executionCwd. The selected host is explicit and never silently replaced.`,
                 parameters: {
                     type: "object",
                     properties: {
@@ -370,6 +405,18 @@ For jobs that use a connected MCP, pass the exact tool names in mcpTools. This b
                             type: "string",
                             description: "Optional model id for this routine. The channel/app/engine default is used when omitted.",
                         },
+                        executionHostId: {
+                            type: "string",
+                            description: "Optional exact paired execution host id. Use manage-automations action=list-hosts first.",
+                        },
+                        executionEngine: {
+                            type: "string",
+                            description: "Optional host engine id, for example codex-cli or claude-cli.",
+                        },
+                        executionCwd: {
+                            type: "string",
+                            description: "Optional workspace path on the selected host; otherwise the connector's configured workspace is used.",
+                        },
                         mcpTools: {
                             type: "array",
                             items: { type: "string" },

package/dist/notifications/routes.d.ts

@@ -16,18 +16,18 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error?: undefined;
     ok?: undefined;
 } | {
-    count?: undefined;
     updated: number;
     error?: undefined;
     ok?: undefined;
-} | {
     count?: undefined;
+} | {
     updated?: undefined;
     error: string;
     ok?: undefined;
-} | {
     count?: undefined;
+} | {
     updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
+    count?: undefined;
 }>>;

package/dist/observability/routes.d.ts

@@ -41,27 +41,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,9 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
+    found?: undefined;
     deleted?: undefined;
-    id?: undefined;
-    provider?: undefined;
     providers: {
         id: string;
         label: string;
@@ -88,46 +87,47 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    found?: undefined;
+    provider?: undefined;
     registered?: undefined;
+    id?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
     deleted?: undefined;
-    id?: undefined;
     providers?: undefined;
     count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
+    id?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
     deleted?: undefined;
-    provider?: undefined;
     providers?: undefined;
     count?: undefined;
+    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
-    provider?: undefined;
+    found?: undefined;
     providers?: undefined;
     count?: undefined;
-    found?: undefined;
+    provider?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
+    found?: undefined;
     deleted?: undefined;
-    provider?: undefined;
     providers?: undefined;
     count?: undefined;
-    found?: undefined;
+    provider?: undefined;
     registered: boolean;
     id: string;
     label: string;