create-windy 0.8.0 → 0.8.1

package/template/apps/server/src/agent/run-operation-policy.ts

@@ -1,3 +1,4 @@
+import { AgentRunFacadeError } from "./run-errors.js";
 import { resolveProviderEgress } from "@southwind-ai/modules";
 import type { RegisteredOperation } from "./run-operation-registry.js";
 
@@ -18,3 +19,13 @@ export function publicAgentOperationPolicy(
     release: structuredClone(operation.release),
   };
 }
+
+export function assertAgentRuntimeAssembled(operation: RegisteredOperation) {
+  if (operation.definition.isolatedExecution) {
+    throw new AgentRunFacadeError(
+      "RUNTIME_UNAVAILABLE",
+      "隔离执行 Runtime 尚未装配",
+      503,
+    );
+  }
+}

package/template/apps/server/src/agent/workflow-durable-runtime-input.ts

@@ -1,3 +1,4 @@
+import type { StructuredLogger } from "@southwind-ai/shared";
 import type { DurableHandlerRegistry } from "@southwind-ai/jobs";
 import { DurableArtifactService } from "../jobs/artifact-service.js";
 import type { DurableJobService } from "../jobs/service.js";
@@ -14,18 +15,20 @@ export function workflowDurableInput([durable, storage, logger]: readonly [
   {
     readonly blobStore: ConstructorParameters<typeof DurableArtifactService>[1];
   },
-  {
-    error(fields: Record<string, unknown>, message: string): void;
-  },
+  Pick<StructuredLogger, "error">,
 ]) {
   return {
     jobs: durable.service,
     jobWorker: durable.worker,
     jobRegistry: durable.registry,
     jobArtifacts: new DurableArtifactService(durable.facts, storage.blobStore),
-    onWorkflowContinuationError: (error: unknown) =>
+    onWorkflowContinuationError: (_error: unknown) =>
       logger.error(
-        { event: "agent.workflow.continuation.failed", error },
+        {
+          event: "agent.workflow.continuation.failed",
+          outcome: "failure",
+          errorCode: "AGENT_WORKFLOW_CONTINUATION_FAILED",
+        },
         "Agent Workflow continuation 派发失败",
       ),
   };

package/template/apps/server/src/jobs/legacy-service-runtime.ts

@@ -10,6 +10,8 @@ import type { BulkDataRepository } from "../bulk-data/repository.js";
 import type { BulkResourceHandler } from "../bulk-data/resource-handler.js";
 // @windy-module system.bulk-data end
 import type { createServerRuntime } from "../runtime.js";
+import type { StructuredLogger } from "@southwind-ai/shared";
+import { createServerLogger } from "../observability/structured-logger.js";
 import type { RequestActor } from "../guards.js";
 // @windy-module system.bulk-data begin
 import { evaluateAccessGuards } from "../access-guards.js";
@@ -48,6 +50,7 @@ interface LegacyServiceRuntimeInput {
   // @windy-module system.workflow end
   installModuleDurableHandlers?: (registry: DurableHandlerRegistry) => void;
   durableContextualize?: DurableWorkerOptions["contextualize"];
+  logger?: StructuredLogger;
 }
 
 export function createLegacyServiceRuntime(input: LegacyServiceRuntimeInput) {
@@ -61,6 +64,7 @@ export function createLegacyServiceRuntime(input: LegacyServiceRuntimeInput) {
   input.installModuleDurableHandlers?.(registry);
   const worker = new DurableJobWorker(execution, registry, {
     contextualize: input.durableContextualize,
+    logger: input.logger ?? createServerLogger(),
   });
   // @windy-module system.workflow begin
   const workflowTimeout = new WorkflowTimeoutRuntime(

package/template/apps/server/src/jobs/runtime-logging.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, test } from "bun:test";
+import { DurableHandlerRegistry } from "@southwind-ai/jobs";
+import {
+  createStructuredLogger,
+  type StructuredLogger,
+} from "@southwind-ai/shared";
+import { InMemoryDurableExecutionRepository } from "./in-memory-execution.js";
+import { DurableJobService } from "./service.js";
+import { DurableJobWorker } from "./worker.js";
+
+const base = new Date("2026-09-30T00:00:00.000Z");
+
+function capture() {
+  const records: Record<string, unknown>[] = [];
+  const write = (record: Record<string, unknown>) => records.push(record);
+  const logger = createStructuredLogger(
+    { info: write, warn: write, error: write },
+    "windy-server",
+  );
+  return { logger, records };
+}
+
+async function fixture(
+  handler?: () => void | Promise<void>,
+  logger?: StructuredLogger,
+) {
+  const repository = new InMemoryDurableExecutionRepository();
+  const service = new DurableJobService(repository, () => base);
+  const registry = new DurableHandlerRegistry();
+  if (handler)
+    registry.register({
+      key: "test.handler",
+      payload: { parse: (value) => value },
+      execute: handler,
+    });
+  const worker = new DurableJobWorker(repository, registry, {
+    logger,
+    now: () => base,
+    leaseDurationMs: 60_000,
+  });
+  return { service, worker };
+}
+
+describe("Durable Job runtime logging", () => {
+  test("idle 无日志；每个实际 attempt 仅一条开始和一条完成", async () => {
+    const { logger, records } = capture();
+    const { service, worker } = await fixture(() => undefined, logger);
+    expect(await worker.runNext("default", "worker-a")).toEqual({
+      status: "idle",
+    });
+    expect(records).toEqual([]);
+    const submitted = await service.submit({
+      handlerKey: "test.handler",
+      idempotencyKey: "job-log-success",
+      payload: { secret: "secret-payload" },
+      requestedBy: "user-secret",
+      stageKeys: ["prepare", "apply"],
+    });
+    expect(await worker.runNext("default", "worker-a")).toEqual({
+      status: "succeeded",
+      jobId: submitted.job.id,
+    });
+    expect(await worker.runNext("default", "worker-a")).toEqual({
+      status: "succeeded",
+      jobId: submitted.job.id,
+    });
+    expect(records.map((record) => record.event)).toEqual([
+      "job.attempt.started",
+      "job.attempt.completed",
+      "job.attempt.started",
+      "job.attempt.completed",
+    ]);
+    expect(records.map((record) => record.stageKey)).toEqual([
+      "prepare",
+      "prepare",
+      "apply",
+      "apply",
+    ]);
+    for (const record of records) {
+      expect(record).toMatchObject({
+        jobId: submitted.job.id,
+        attemptNumber: 1,
+        handlerKey: "test.handler",
+        queue: "default",
+      });
+    }
+    const serialized = JSON.stringify(records);
+    expect(serialized).not.toContain("secret-payload");
+    expect(serialized).not.toContain("user-secret");
+    expect(serialized).not.toContain("leaseToken");
+  });
+
+  test("未注册 handler 与执行失败都配对，且只记录稳定错误码", async () => {
+    const missing = capture();
+    const missingFixture = await fixture(undefined, missing.logger);
+    await missingFixture.service.submit({
+      handlerKey: "test.handler",
+      idempotencyKey: "job-missing",
+      payload: { secret: "secret-payload" },
+      requestedBy: "user-1",
+    });
+    expect(
+      (await missingFixture.worker.runNext("default", "worker-a")).status,
+    ).toBe("failed");
+    expect(missing.records.map((record) => record.event)).toEqual([
+      "job.attempt.started",
+      "job.attempt.completed",
+    ]);
+    expect(missing.records[1]?.errorCode).toBe("HANDLER_NOT_REGISTERED");
+
+    const failed = capture();
+    const failedFixture = await fixture(() => {
+      throw new Error("secret-error");
+    }, failed.logger);
+    await failedFixture.service.submit({
+      handlerKey: "test.handler",
+      idempotencyKey: "job-failed",
+      payload: { secret: "secret-payload" },
+      requestedBy: "user-1",
+    });
+    expect(
+      (await failedFixture.worker.runNext("default", "worker-a")).status,
+    ).toBe("failed");
+    expect(failed.records.map((record) => record.event)).toEqual([
+      "job.attempt.started",
+      "job.attempt.completed",
+    ]);
+    expect(failed.records[1]?.errorCode).toBe("JOB_ATTEMPT_FAILED");
+    expect(JSON.stringify(failed.records)).not.toContain("secret-error");
+  });
+
+  test("取消与租约失效各写一次安全终态", async () => {
+    const cancelled = capture();
+    let entered: () => void = () => undefined;
+    let release: () => void = () => undefined;
+    const enteredPromise = new Promise<void>((resolve) => {
+      entered = resolve;
+    });
+    const releasePromise = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const cancelledFixture = await fixture(async () => {
+      entered();
+      await releasePromise;
+    }, cancelled.logger);
+    const cancelledJob = await cancelledFixture.service.submit({
+      handlerKey: "test.handler",
+      idempotencyKey: "job-cancelled",
+      payload: {},
+      requestedBy: "user-1",
+    });
+    const run = cancelledFixture.worker.runNext("default", "worker-a");
+    await enteredPromise;
+    await cancelledFixture.worker.cancel(cancelledJob.job.id);
+    release();
+    expect((await run).status).toBe("cancelled");
+    expect(cancelled.records.map((record) => record.event)).toEqual([
+      "job.attempt.started",
+      "job.attempt.completed",
+    ]);
+    expect(cancelled.records[1]?.errorCode).toBe("JOB_CANCELLED");
+
+    const lost = capture();
+    const repository = new InMemoryDurableExecutionRepository();
+    const service = new DurableJobService(repository, () => base);
+    await service.submit({
+      handlerKey: "test.handler",
+      idempotencyKey: "job-lease-lost",
+      payload: {},
+      requestedBy: "user-1",
+    });
+    let now = base;
+    const registry = new DurableHandlerRegistry().register({
+      key: "test.handler",
+      payload: { parse: (value) => value },
+      execute: async (_payload, context) => {
+        now = new Date(base.getTime() + 100);
+        await context.heartbeat();
+      },
+    });
+    const worker = new DurableJobWorker(repository, registry, {
+      logger: lost.logger,
+      now: () => now,
+      leaseDurationMs: 10,
+    });
+    expect((await worker.runNext("default", "worker-a")).status).toBe(
+      "lease-lost",
+    );
+    expect(lost.records.map((record) => record.event)).toEqual([
+      "job.attempt.started",
+      "job.attempt.completed",
+    ]);
+    expect(lost.records[1]?.errorCode).toBe("JOB_LEASE_LOST");
+  });
+
+  test("logger 抛错不改变 Job 结果", async () => {
+    const fail = () => {
+      throw new Error("sink down");
+    };
+    const logger: StructuredLogger = { info: fail, warn: fail, error: fail };
+    const { service, worker } = await fixture(() => undefined, logger);
+    await service.submit({
+      handlerKey: "test.handler",
+      idempotencyKey: "sink-failure",
+      payload: {},
+      requestedBy: "user-1",
+    });
+    expect((await worker.runNext("default", "worker-a")).status).toBe(
+      "succeeded",
+    );
+  });
+});

package/template/apps/server/src/jobs/runtime-logging.ts

@@ -0,0 +1,58 @@
+import type { ClaimedDurableJob } from "@southwind-ai/jobs";
+import type { StructuredLogger } from "@southwind-ai/shared";
+
+export type JobAttemptResult =
+  | "succeeded"
+  | "failed"
+  | "cancelled"
+  | "lease-lost";
+
+/** Only canonical claim coordinates enter operational logs. */
+export function logJobAttemptStarted(
+  logger: StructuredLogger | undefined,
+  claim: ClaimedDurableJob,
+): void {
+  safeLog(() =>
+    logger?.info({
+      event: "job.attempt.started",
+      jobId: claim.jobId,
+      stageKey: claim.stage.key,
+      attemptNumber: claim.stage.currentAttempt,
+      handlerKey: claim.job.handlerKey,
+      queue: claim.job.queue,
+    }),
+  );
+}
+
+export function logJobAttemptCompleted(
+  logger: StructuredLogger | undefined,
+  claim: ClaimedDurableJob,
+  status: JobAttemptResult,
+  durationMs: number,
+  errorCode?: string,
+): void {
+  const fields = {
+    event: "job.attempt.completed",
+    jobId: claim.jobId,
+    stageKey: claim.stage.key,
+    attemptNumber: claim.stage.currentAttempt,
+    handlerKey: claim.job.handlerKey,
+    queue: claim.job.queue,
+    durationMs: Number(durationMs.toFixed(3)),
+    outcome:
+      status === "succeeded" ? ("success" as const) : ("failure" as const),
+    ...(errorCode ? { errorCode } : {}),
+  };
+  safeLog(() => {
+    if (status === "failed" || status === "lease-lost") logger?.error(fields);
+    else logger?.info(fields);
+  });
+}
+
+function safeLog(write: () => void): void {
+  try {
+    write();
+  } catch {
+    // Runtime logging is best effort; Job fact writes retain their own contract.
+  }
+}

package/template/apps/server/src/jobs/worker.ts

@@ -5,6 +5,11 @@ import type {
   ManualJobRecovery,
 } from "./execution-repository.js";
 import { createDurableArtifactPublisher } from "./artifact-publisher.js";
+import type { StructuredLogger } from "@southwind-ai/shared";
+import {
+  logJobAttemptCompleted,
+  logJobAttemptStarted,
+} from "./runtime-logging.js";
 import {
   DurableHandlerError,
   type DurableHandlerContext,
@@ -25,6 +30,7 @@ export interface DurableWorkerOptions {
   leaseDurationMs?: number;
   retryDelayMs?: number;
   now?: () => Date;
+  logger?: StructuredLogger;
   contextualize?: (input: {
     claim: ClaimedDurableJob;
     moduleName?: string;
@@ -37,6 +43,7 @@ export class DurableJobWorker {
   private readonly retryDelayMs: number;
   private readonly now: () => Date;
   private readonly contextualize?: DurableWorkerOptions["contextualize"];
+  private readonly logger?: StructuredLogger;
   private readonly activeRuns = new Map<string, AbortController>();
 
   constructor(
@@ -48,6 +55,7 @@ export class DurableJobWorker {
     this.retryDelayMs = options.retryDelayMs || 1_000;
     this.now = options.now || (() => new Date());
     this.contextualize = options.contextualize;
+    this.logger = options.logger;
   }
 
   async runNext(queue: string, workerId: string): Promise<DurableRunResult> {
@@ -59,20 +67,54 @@ export class DurableJobWorker {
       leaseDurationMs: this.leaseDurationMs,
     });
     if (!claim) return { status: "idle" };
-    const handler = this.handlers.get(claim.job.handlerKey);
-    if (!handler) {
-      await this.repository.fail(
+    const startedAt = performance.now();
+    logJobAttemptStarted(this.logger, claim);
+    try {
+      const handler = this.handlers.get(claim.job.handlerKey);
+      if (!handler) {
+        await this.repository.fail(
+          claim,
+          {
+            code: "HANDLER_NOT_REGISTERED",
+            message: `任务 handler 未注册：${claim.job.handlerKey}`,
+            retryable: false,
+          },
+          this.now(),
+        );
+        logJobAttemptCompleted(
+          this.logger,
+          claim,
+          "failed",
+          performance.now() - startedAt,
+          "HANDLER_NOT_REGISTERED",
+        );
+        return { status: "failed", jobId: claim.jobId };
+      }
+      const result = await this.execute(claim, handler);
+      logJobAttemptCompleted(
+        this.logger,
         claim,
-        {
-          code: "HANDLER_NOT_REGISTERED",
-          message: `任务 handler 未注册：${claim.job.handlerKey}`,
-          retryable: false,
-        },
-        this.now(),
+        result.status,
+        performance.now() - startedAt,
+        result.status === "failed"
+          ? "JOB_ATTEMPT_FAILED"
+          : result.status === "cancelled"
+            ? "JOB_CANCELLED"
+            : result.status === "lease-lost"
+              ? "JOB_LEASE_LOST"
+              : undefined,
+      );
+      return result;
+    } catch (error) {
+      logJobAttemptCompleted(
+        this.logger,
+        claim,
+        "failed",
+        performance.now() - startedAt,
+        "JOB_WORKER_ERROR",
       );
-      return { status: "failed", jobId: claim.jobId };
+      throw error;
     }
-    return this.execute(claim, handler);
   }
 
   async cancel(jobId: string) {
@@ -104,7 +146,7 @@ export class DurableJobWorker {
   private async execute(
     claim: ClaimedDurableJob,
     handler: RegisteredDurableHandler,
-  ): Promise<DurableRunResult> {
+  ): Promise<Exclude<DurableRunResult, { status: "idle" }>> {
     const abort = new AbortController();
     this.activeRuns.set(claim.jobId, abort);
     const identity = identityOf(claim);

package/template/apps/server/src/observability/bootstrap.ts

@@ -49,8 +49,5 @@ export function logPlatformStartup(
     { event: "feature.manifest.synchronized", ...input.featureSync },
     "Feature Manifest 已同步",
   );
-  logger.info(
-    { event: "service.started", component: "windy-server", port: input.port },
-    "服务已启动",
-  );
+  logger.info({ event: "service.started", port: input.port }, "服务已启动");
 }

package/template/apps/server/src/observability/http-observability.ts

@@ -1,9 +1,8 @@
+import type { StructuredLogger } from "@southwind-ai/shared";
 import type { RequestGuardContext } from "../guards.js";
 import type { RequestObservation, RuntimeMetrics } from "./metrics.js";
 
-export interface StructuredRequestLogger {
-  info(fields: Record<string, unknown>, message: string): void;
-}
+export type StructuredRequestLogger = Pick<StructuredLogger, "info">;
 
 export class HttpObservability {
   constructor(

package/template/apps/server/src/observability/structured-logger.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { createServerLogger } from "./structured-logger.js";
+
+describe("Server Pino operational logger", () => {
+  test("实际输出单行 JSON 且没有 Pino 隐含字段或自由文本", () => {
+    const lines: string[] = [];
+    const logger = createServerLogger({ write: (line) => lines.push(line) });
+    logger.error(
+      {
+        event: "agent.workflow.continuation.failed",
+        outcome: "failure",
+        errorCode: "AGENT_WORKFLOW_CONTINUATION_FAILED",
+        requestId: "request-1",
+        error: new Error("secret-stack"),
+      } as unknown as Parameters<typeof logger.error>[0],
+      "secret-message",
+    );
+    expect(lines).toHaveLength(1);
+    const record = JSON.parse(lines[0] ?? "") as Record<string, unknown>;
+    expect(record).toMatchObject({
+      level: "error",
+      component: "windy-server",
+      event: "agent.workflow.continuation.failed",
+      requestId: "request-1",
+    });
+    expect(record).not.toHaveProperty("time");
+    expect(record).not.toHaveProperty("msg");
+    expect(lines[0]).not.toContain("secret-stack");
+    expect(lines[0]).not.toContain("secret-message");
+  });
+});

package/template/apps/server/src/observability/structured-logger.ts

@@ -0,0 +1,27 @@
+import { createStructuredLogger } from "@southwind-ai/shared";
+import pino, { type DestinationStream } from "pino";
+
+/** Pino 只负责写出；字段选择和大小限制由共享契约完成。 */
+export function createServerLogger(destination?: DestinationStream) {
+  const options = {
+    base: null,
+    timestamp: false,
+    formatters: { level: (level: string) => ({ level }) },
+  };
+  const sink = destination ? pino(options, destination) : pino(options);
+  const write = (
+    level: "info" | "warn" | "error",
+    record: Record<string, unknown>,
+  ) => {
+    const { level: _level, ...fields } = record;
+    sink[level](fields);
+  };
+  return createStructuredLogger(
+    {
+      info: (record) => write("info", record),
+      warn: (record) => write("warn", record),
+      error: (record) => write("error", record),
+    },
+    "windy-server",
+  );
+}

package/template/apps/server/src/platform-bootstrap.ts

@@ -1,14 +1,20 @@
 import { loadPlatformConfig } from "@southwind-ai/config";
-import pino from "pino";
+import { createServerLogger } from "./observability/structured-logger.js";
 import { createServerPersistence } from "./persistence.js";
 
 export function createPlatformBootstrap() {
-  const logger = pino({ name: "windy-server" });
+  const logger = createServerLogger();
   const platformConfig = loadPlatformConfig();
   const persistence = createServerPersistence(
     process.env,
     (status) => {
-      logger.error({ audit: status }, "审计持久化进入降级状态");
+      logger.error({
+        event: "audit.persistence.degraded",
+        outcome: "failure",
+        errorCode: "AUDIT_PERSISTENCE_DEGRADED",
+        queued: status.queued,
+        dropped: status.dropped,
+      });
     },
     platformConfig,
   );

package/template/apps/server/src/startup-finalization.ts

@@ -1,3 +1,4 @@
+import type { StructuredLogger } from "@southwind-ai/shared";
 import type { ModuleManifest } from "@southwind-ai/modules";
 import type { InitializedModuleHosts } from "./module-host.js";
 import { validateInstalledRuntime } from "./module-runtime-validation.js";
@@ -16,9 +17,8 @@ export function finalizePlatformStartup(input: {
   providers?: readonly string[];
   schedulerWorker?: { start(): void; stop(): void };
   disposeAgentRuntime?: () => Promise<unknown> | unknown;
-  logger: Parameters<typeof logServerStartup>[0] & {
-    error(fields: Record<string, unknown>, message: string): void;
-  };
+  logger: Parameters<typeof logServerStartup>[0] &
+    Pick<StructuredLogger, "error">;
   featureSync: Parameters<typeof logServerStartup>[1];
   persistenceEnabled: boolean;
 }): void {

package/template/apps/server/src/system/built-in-roles.test.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test";
+import { createFoundationSnapshot } from "../foundation.js";
+import { createBuiltInRoleSeeds } from "./built-in-roles.js";
+
+test("built-in roles only grant permissions in the installed capability catalog", () => {
+  const snapshot = createFoundationSnapshot();
+  const coreKeys = new Set([
+    "system.menu.read",
+    "system.profile.read",
+    "system.user.read",
+  ]);
+  snapshot.permissions = snapshot.permissions.filter(({ key }) =>
+    coreKeys.has(key),
+  );
+  const roles = createBuiltInRoleSeeds(snapshot);
+  for (const role of roles) {
+    expect(role.permissionKeys.every((key) => coreKeys.has(key))).toBe(true);
+  }
+  expect(roles.find(({ code }) => code === "user")?.permissionKeys).toEqual([
+    "system.menu.read",
+    "system.profile.read",
+  ]);
+});

package/template/apps/server/src/system/built-in-roles.ts

@@ -25,17 +25,23 @@ export function createBuiltInRoleSeeds(
   snapshot: FoundationSnapshot,
 ): RoleSeed[] {
   const allPermissions = snapshot.permissions.map(({ key }) => key).sort();
+  const registeredPermissions = new Set<string>(allPermissions);
+  const supportedOrdinaryPermissions = ordinaryPermissions.filter((key) =>
+    registeredPermissions.has(key),
+  );
   const developerPermissions = snapshot.permissions
     .filter(({ accessRisk }) => !accessRisk || accessRisk === "standard")
     .map(({ key }) => key)
     .sort();
   const allMenus = collectNavigableMenuKeys(snapshot.menus);
   const departmentManagerPermissions = [
-    ...ordinaryPermissions,
+    ...supportedOrdinaryPermissions,
     "system.department.read",
     "system.user.read",
     "system.user-directory.read",
-  ].sort();
+  ]
+    .filter((key) => registeredPermissions.has(key))
+    .sort();
   return [
     role(
       "role_super_admin",
@@ -58,8 +64,8 @@ export function createBuiltInRoleSeeds(
       "user",
       "普通用户",
       "self",
-      ordinaryPermissions,
-      menuKeysForPermissions(snapshot, ordinaryPermissions),
+      supportedOrdinaryPermissions,
+      menuKeysForPermissions(snapshot, supportedOrdinaryPermissions),
     ),
     role(
       "role_developer",

package/template/apps/web/src/pages/system/composables/useResourceEditor.ts

@@ -33,6 +33,17 @@ export function useResourceEditor(options: {
     try {
       const normalized = { ...payload };
       delete normalized._transitionTargetDepartmentId;
+      if (
+        options.key === "users" &&
+        !item.value &&
+        (typeof payload.temporaryPassword !== "string" ||
+          !payload.temporaryPassword)
+      ) {
+        toast.error("请设置一次性初始密码", {
+          description: "密码至少 12 个字符，创建后首次登录即可修改。",
+        });
+        return false;
+      }
       if (
         options.key === "departments" &&
         item.value &&
@@ -54,12 +65,12 @@ export function useResourceEditor(options: {
           ? await saveUserAccount(
               normalized,
               savedAccountId.value,
-              options.save,
-              toast,
-              (record) => {
-                savedAccountId.value = record.id;
+              async (accountPayload, id) => {
+                const record = await options.save(accountPayload, id);
+                if (record) savedAccountId.value = record.id;
+                return record;
               },
-              !item.value,
+              toast,
             )
           : await options.save(normalized, item.value?.id);
       if (saved) options.mutated();