create-windy 0.6.12 → 0.6.15

package/template/apps/server/src/module-host/request-context.ts

@@ -6,6 +6,8 @@ import type {
   ModuleAiOperationPort,
   ModuleAiOperationReadinessPortV1,
   ModuleAiScreenshotIntakePortV1,
+  ModuleAgentSessionMemoryPortV1,
+  ModuleAuthoritativeSourceInvalidationPortV1,
   ModuleAuditEmitInput,
   ModuleAuditEmitter,
   ModuleRequestContext,
@@ -38,6 +40,9 @@ import {
 import { unavailableModuleSecretPort } from "./module-secret-port.js";
 import { unavailableModuleStoragePort } from "./storage-port.js";
 import { unavailableModuleStorageWritePort } from "./storage-write-unavailable.js";
+// @windy-module system.agent begin
+import { createModuleWorkflowInputMaterializationPort } from "./workflow-input-materialization.js";
+// @windy-module system.agent end
 
 type ServerRuntime = ReturnType<typeof createServerRuntime>;
 
@@ -105,12 +110,25 @@ export interface ModuleRequestContextInput {
   aiOperations?: ModuleAiOperationPort;
   aiReadiness?: ModuleAiOperationReadinessPortV1;
   screenshots?: ModuleAiScreenshotIntakePortV1;
+  sessionMemory?: ModuleAgentSessionMemoryPortV1;
+  sourceInvalidation?: ModuleAuthoritativeSourceInvalidationPortV1;
   onAuditEmit?: (action: string) => void;
 }
 
 export function buildModuleRequestContext(
   input: ModuleRequestContextInput,
 ): ModuleRequestContext {
+  const jobs = createModuleJobPort({
+    moduleName: input.moduleName,
+    guardContext: input.guardContext,
+    runtime: input.runtime,
+    jobs: input.jobs,
+    control: input.jobControl,
+    reauthorize: input.reauthorizeJobs,
+  });
+  // @windy-module system.agent begin
+  const materializationHandlerKey = `${input.moduleName}.workflow-input-materialize`;
+  // @windy-module system.agent end
   return {
     requestId: input.guardContext.requestId,
     signal: input.signal ?? new AbortController().signal,
@@ -128,14 +146,28 @@ export function buildModuleRequestContext(
     ...(input.screenshots
       ? { screenshots: narrowModuleScreenshotIntakePort(input.screenshots) }
       : {}),
-    jobs: createModuleJobPort({
-      moduleName: input.moduleName,
-      guardContext: input.guardContext,
-      runtime: input.runtime,
-      jobs: input.jobs,
-      control: input.jobControl,
-      reauthorize: input.reauthorizeJobs,
-    }),
+    ...(input.sessionMemory ? { sessionMemory: input.sessionMemory } : {}),
+    ...(input.sourceInvalidation
+      ? { sourceInvalidation: input.sourceInvalidation }
+      : {}),
+    jobs,
+    // @windy-module system.agent begin
+    ...(input.jobs &&
+    input.manifest.tasks.some(({ key }) => key === materializationHandlerKey)
+      ? {
+          workflowInputMaterialization:
+            createModuleWorkflowInputMaterializationPort({
+              moduleName: input.moduleName,
+              guardContext: input.guardContext,
+              jobs: input.jobs,
+              moduleJobs: jobs,
+              ...(input.reauthorizeJobs
+                ? { reauthorize: input.reauthorizeJobs }
+                : {}),
+            }),
+        }
+      : {}),
+    // @windy-module system.agent end
     secrets: input.secrets ?? unavailableModuleSecretPort(),
     storage: input.storage ?? unavailableModuleStoragePort(input.moduleName),
     storageWriter:

package/template/apps/server/src/module-host/route-install-context.ts

@@ -0,0 +1,65 @@
+import type { DurableJobs } from "@southwind-ai/jobs";
+import type {
+  ModuleAiArtifactRef,
+  ModuleAiArtifactPort,
+  ModuleAiOperationPort,
+  ModuleAiOperationReadinessPortV1,
+  ModuleAiScreenshotIntakePortV1,
+  ModuleAgentSessionMemoryPortV1,
+  ModuleAuthoritativeSourceInvalidationPortV1,
+} from "@southwind-ai/server-sdk";
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import type { createServerRuntime } from "../runtime.js";
+import type { routeContext } from "../system/route-helpers.js";
+import type { ModuleJobControlRuntime } from "./job-port.js";
+import type { ModuleStorageServices } from "./storage-port.js";
+import type { ModuleUserDirectoryServices } from "./user-directory-port.js";
+
+type GuardContext = ReturnType<typeof routeContext>["guardContext"];
+
+export interface ModuleRouteInstallContext {
+  runtime: ReturnType<typeof createServerRuntime>;
+  features: readonly FeatureFlagDefinition[];
+  jobs?: DurableJobs;
+  jobControl?: ModuleJobControlRuntime;
+  storage?: ModuleStorageServices;
+  // @windy-module system.storage begin
+  reportStaging?: import("../report-staging/service.js").ReportStagingService;
+  // @windy-module system.storage end
+  userDirectory?: Omit<ModuleUserDirectoryServices, "runtime" | "features">;
+  aiArtifacts?: (
+    moduleName: string,
+    guardContext: GuardContext,
+    signal: AbortSignal,
+  ) => ModuleAiArtifactPort;
+  validateAiArtifact?: (
+    reference: ModuleAiArtifactRef,
+    moduleName: string,
+    guardContext: GuardContext,
+  ) => ModuleAiArtifactRef;
+  aiOperations?: (
+    moduleName: string,
+    guardContext: GuardContext,
+    signal: AbortSignal,
+  ) => ModuleAiOperationPort;
+  aiReadiness?: (
+    moduleName: string,
+    guardContext: GuardContext,
+    signal: AbortSignal,
+  ) => ModuleAiOperationReadinessPortV1;
+  screenshots?: (
+    moduleName: string,
+    guardContext: GuardContext,
+    signal: AbortSignal,
+  ) => ModuleAiScreenshotIntakePortV1;
+  sessionMemory?: (
+    moduleName: string,
+    guardContext: GuardContext,
+    signal: AbortSignal,
+  ) => ModuleAgentSessionMemoryPortV1;
+  sourceInvalidation?: (
+    moduleName: string,
+    guardContext: GuardContext,
+    signal: AbortSignal,
+  ) => ModuleAuthoritativeSourceInvalidationPortV1;
+}

package/template/apps/server/src/module-host/route-installer.ts

@@ -1,84 +1,29 @@
-import type { DurableJobs } from "@southwind-ai/jobs";
-import type { FeatureFlagDefinition } from "@southwind-ai/shared";
 import { evaluateRouteGuards, findFeature } from "../route-guards.js";
 import { forbidden, routeContext } from "../system/route-helpers.js";
 import type { RouteApp } from "../system/route-types.js";
-import type { createServerRuntime } from "../runtime.js";
 import type { InitializedModuleHosts } from "./initialize.js";
-import type {
-  ModuleAiArtifactRef,
-  ModuleAiArtifactPort,
-  ModuleAiOperationPort,
-  ModuleAiOperationReadinessPortV1,
-  ModuleAiScreenshotIntakePortV1,
-} from "@southwind-ai/server-sdk";
 // @windy-module system.storage begin
 import { ModuleReportStagingError } from "@southwind-ai/server-sdk";
 // @windy-module system.storage end
 import { buildModuleRequestContext } from "./request-context.js";
 import {
   createModuleStoragePort,
-  type ModuleStorageServices,
 } from "./storage-port.js";
 import {
   createModuleUserDirectoryPort,
-  type ModuleUserDirectoryServices,
 } from "./user-directory-port.js";
 import { createModuleStorageScope } from "./storage-scope.js";
 import { createModuleStorageWritePort } from "./storage-write-port.js";
-import type { ModuleJobControlRuntime } from "./job-port.js";
 import { createModuleSecretPort } from "./module-secret-port.js";
 import { createGovernedModuleScreenshotIntakePort } from "./screenshot-intake-port.js";
 import { ScreenshotIntakePlanStore } from "./screenshot-intake-store.js";
 // @windy-module system.storage begin
-import type { ReportStagingService } from "../report-staging/service.js";
 import { createModuleReportStagingPort } from "./report-staging-port.js";
 // @windy-module system.storage end
-
-type ServerRuntime = ReturnType<typeof createServerRuntime>;
+import type { ModuleRouteInstallContext } from "./route-install-context.js";
 
 type RouteMethod = "get" | "post" | "put" | "delete";
 
-export interface ModuleRouteInstallContext {
-  runtime: ServerRuntime;
-  features: readonly FeatureFlagDefinition[];
-  jobs?: DurableJobs;
-  jobControl?: ModuleJobControlRuntime;
-  /** 平台存储服务；提供后模块获得受限 Upload/BlobRead Port。 */
-  storage?: ModuleStorageServices;
-  // @windy-module system.storage begin
-  /** Host 持有的大报告暂存生命周期；模块只获得作用域 Port。 */
-  reportStaging?: ReportStagingService;
-  // @windy-module system.storage end
-  /** 平台身份目录；Adapter 会绑定当前请求 Actor 与服务端数据范围。 */
-  userDirectory?: Omit<ModuleUserDirectoryServices, "runtime" | "features">;
-  aiArtifacts?: (
-    moduleName: string,
-    guardContext: ReturnType<typeof routeContext>["guardContext"],
-    signal: AbortSignal,
-  ) => ModuleAiArtifactPort;
-  validateAiArtifact?: (
-    reference: ModuleAiArtifactRef,
-    moduleName: string,
-    guardContext: ReturnType<typeof routeContext>["guardContext"],
-  ) => ModuleAiArtifactRef;
-  aiOperations?: (
-    moduleName: string,
-    guardContext: ReturnType<typeof routeContext>["guardContext"],
-    signal: AbortSignal,
-  ) => ModuleAiOperationPort;
-  aiReadiness?: (
-    moduleName: string,
-    guardContext: ReturnType<typeof routeContext>["guardContext"],
-    signal: AbortSignal,
-  ) => ModuleAiOperationReadinessPortV1;
-  screenshots?: (
-    moduleName: string,
-    guardContext: ReturnType<typeof routeContext>["guardContext"],
-    signal: AbortSignal,
-  ) => ModuleAiScreenshotIntakePortV1;
-}
-
 /**
  * 把模块经 Host 注册的路由定义安装为走统一 Guard 的 API 路由。
  * Guard（权限 / Feature / License）与 security.denied 审计由
@@ -217,6 +162,16 @@ export function installModuleRoutes(
                   ),
               })
             : undefined,
+        sessionMemory: context.sessionMemory?.(
+          moduleName,
+          route.guardContext,
+          route.request.signal,
+        ),
+        sourceInvalidation: context.sourceInvalidation?.(
+          moduleName,
+          route.guardContext,
+          route.request.signal,
+        ),
         jobs: context.jobs,
         jobControl: context.jobControl,
         reauthorizeJobs: async () =>

package/template/apps/server/src/module-host/scoped-host.ts

@@ -11,7 +11,7 @@ import {
 } from "@southwind-ai/server-sdk";
 import type {
   RegisteredModuleAiOperationHandler,
-  RegisteredModuleDebugSessionProvider,
+  RegisteredModuleAgentSessionProvider,
   RegisteredModuleDurableHandler,
   RegisteredModuleGovernedResource,
   RegisteredModuleRolePreset,
@@ -21,7 +21,7 @@ import type {
   RegisteredModuleTaskHandler,
   RegisteredModuleToolHandler,
 } from "./initialize-contracts.js";
-import { validateDebugSessionProviderRegistration } from "./debug-session-provider-registration.js";
+import { validateAgentSessionProviderRegistration } from "./agent-session-provider-registration.js";
 import { registerModuleDurableHandler } from "./durable-handler-registration.js";
 import { registerGovernedResources } from "./governed-resources.js";
 import { registerResourceFileAccessPolicies } from "./resource-file-policies.js";
@@ -62,8 +62,8 @@ export interface HostCollections {
   rolePresetKeys: Set<string>;
   searchProviders: RegisteredModuleSearchProvider[];
   searchProviderKeys: Set<string>;
-  debugSessionProviders: RegisteredModuleDebugSessionProvider[];
-  debugSessionProviderKeys: Set<string>;
+  agentSessionProviders: RegisteredModuleAgentSessionProvider[];
+  agentSessionProviderKeys: Set<string>;
 }
 
 export function createScopedHost(
@@ -71,6 +71,17 @@ export function createScopedHost(
   state: HostCollections,
 ): ModuleHost {
   const moduleName = manifest.name;
+  const registerAgentSessionProviders: ModuleHost["registerAgentSessionProviders"] =
+    (providers) => {
+      for (const provider of providers) {
+        validateAgentSessionProviderRegistration(manifest, provider);
+        if (state.agentSessionProviderKeys.has(provider.key)) {
+          throw new Error(`Agent 会话 Provider 重复注册：${provider.key}`);
+        }
+        state.agentSessionProviderKeys.add(provider.key);
+        state.agentSessionProviders.push({ moduleName, provider });
+      }
+    };
   return {
     moduleName,
     registerUploadPolicy(policy) {
@@ -219,15 +230,9 @@ export function createScopedHost(
         state.searchProviders.push({ moduleName, provider });
       }
     },
+    registerAgentSessionProviders,
     registerDebugSessionProviders(providers) {
-      for (const provider of providers) {
-        validateDebugSessionProviderRegistration(manifest, provider);
-        if (state.debugSessionProviderKeys.has(provider.key)) {
-          throw new Error(`调试会话 Provider 重复注册：${provider.key}`);
-        }
-        state.debugSessionProviderKeys.add(provider.key);
-        state.debugSessionProviders.push({ moduleName, provider });
-      }
+      registerAgentSessionProviders(providers);
     },
   };
 }

package/template/apps/server/src/module-host/storage-authorization-binding.test.ts

@@ -157,10 +157,10 @@ describe("模块上传会话授权绑定", () => {
     ]);
     const actor = bindModuleUserProjection(
       {
-        id: "service_adk_debug",
+        id: "service_page_agent",
         type: "service",
-        name: "调试服务",
-        roleCodes: ["adk-debug"],
+        name: "PageAgent 客户端",
+        roleCodes: ["client-agent"],
         permissionKeys: ["shop.upload.manage"],
         scopeContext,
       },

package/template/apps/server/src/module-host/storage-port.ts

@@ -14,6 +14,7 @@ import {
   type UploadAuthorizationBinding,
   type FileMetadata,
   type FileService,
+  type BlobStore,
   type UploadSession,
   type UploadService,
 } from "@southwind-ai/storage";
@@ -21,6 +22,8 @@ import {
 export interface ModuleStorageServices {
   uploads: UploadService;
   files: FileService;
+  /** Host-only Durable publication seam；ModuleStoragePort 不暴露 BlobStore。 */
+  blobStore?: BlobStore;
 }
 
 export interface ModuleStorageScope {

package/template/apps/server/src/module-host/workflow-input-artifact-port.test.ts

@@ -0,0 +1,104 @@
+import { expect, test } from "bun:test";
+import type { DurableHandlerArtifactInput } from "@southwind-ai/jobs";
+import { MemoryBlobStore } from "@southwind-ai/storage";
+import { createModuleWorkflowInputArtifactPublicationPort } from "./workflow-input-artifact-port.js";
+
+test("Storage resource 经真实 Durable publication 后才成为 Workflow artifact ref", async () => {
+  const blobs = new MemoryBlobStore();
+  const published: DurableHandlerArtifactInput[] = [];
+  const port = createModuleWorkflowInputArtifactPublicationPort({
+    moduleName: "case",
+    actorId: "actor-1",
+    blobs,
+    storage: {
+      async openResourceFile() {
+        const bytes = new TextEncoder().encode('{"caseId":"case-1"}');
+        return {
+          id: "file_storage_only",
+          purpose: "case-evidence",
+          filename: "case.json",
+          mimeType: "application/json",
+          byteSize: bytes.byteLength,
+          sha256:
+            "b749cb42fc25c341604392803be93cd89343609feddd5d93d5b6596e6d7d31e9",
+          body: new Blob([bytes]).stream(),
+        };
+      },
+    },
+    durable: {
+      jobId: "job-1",
+      stageKey: "prepare",
+      attemptNumber: 1,
+      signal: new AbortController().signal,
+      heartbeat: async () => undefined,
+      progress: async () => undefined,
+      publishArtifact: async () => undefined,
+      async publishArtifactOnce(publicationKey, artifact) {
+        published.push(artifact);
+        return {
+          schemaVersion: 1,
+          publicationKey,
+          artifactId: "dap_real_artifact",
+          jobId: "job-1",
+          stageKey: "prepare",
+          kind: artifact.kind,
+          artifactRef: artifact.artifactRef,
+          sha256: artifact.sha256,
+        };
+      },
+    },
+  });
+
+  const result = await port.publishResource({
+    publicationKey: "case-input-v1",
+    kind: "case-snapshot",
+    filename: "case.json",
+    retentionPolicyKey: "case.analysis",
+    resource: {
+      fileId: "file_storage_only",
+      purpose: "case-evidence",
+      resourceType: "case",
+      resourceId: "case-1",
+    },
+    source: {
+      kind: "case",
+      id: "case-1",
+      version: "42",
+      sequence: 42,
+      digest: `sha256:${"a".repeat(64)}`,
+    },
+  });
+
+  expect(result.artifactId).toBe("dap_real_artifact");
+  expect(result.artifactId).not.toBe("file_storage_only");
+  expect(result.source).toEqual({
+    moduleKey: "case",
+    kind: "case",
+    id: "case-1",
+    version: "42",
+    sequence: 42,
+    digest: `sha256:${"a".repeat(64)}`,
+  });
+  expect(published[0]?.metadata).toMatchObject({
+    sourceModuleKey: "case",
+    sourceId: "case-1",
+    retentionPolicyKey: "case.analysis",
+  });
+  expect(blobs.size).toBe(1);
+  await expect(
+    port.publishJson({
+      publicationKey: "invalid-json",
+      kind: "case-snapshot",
+      filename: "invalid.json",
+      retentionPolicyKey: "case.analysis",
+      source: {
+        kind: "case",
+        id: "case-1",
+        version: "42",
+        sequence: 42,
+      },
+      value: undefined as never,
+    }),
+  ).rejects.toMatchObject({ code: "WORKFLOW_INPUT_ARTIFACT_INVALID" });
+  expect(blobs.size).toBe(1);
+});

package/template/apps/server/src/module-host/workflow-input-artifact-port.ts

@@ -0,0 +1,229 @@
+import { createHash } from "node:crypto";
+import {
+  DurableHandlerError,
+  type DurableHandlerContext,
+} from "@southwind-ai/jobs";
+import {
+  parseModuleWorkflowInputJsonArtifactV1,
+  parseModuleWorkflowInputResourceArtifactV1,
+  type ModuleDurableStoragePort,
+  type ModuleWorkflowInputArtifactPublicationPortV1,
+  type ModuleWorkflowInputArtifactSourceV1,
+} from "@southwind-ai/server-sdk";
+import type { AgentWorkflowArtifactRef, JsonValue } from "@southwind-ai/shared";
+import {
+  artifactRef,
+  type BlobStore,
+  type ContentHash,
+} from "@southwind-ai/storage";
+
+export function createModuleWorkflowInputArtifactPublicationPort(input: {
+  readonly moduleName: string;
+  readonly actorId: string;
+  readonly storage: ModuleDurableStoragePort;
+  readonly blobs: BlobStore;
+  readonly durable: DurableHandlerContext;
+}): ModuleWorkflowInputArtifactPublicationPortV1 {
+  return {
+    async publishResource(spec) {
+      const parsed = parseResource(spec);
+      const opened = await input.storage.openResourceFile(parsed.resource);
+      return publish(input, {
+        ...parsed,
+        mediaType: opened.mimeType,
+        byteSize: opened.byteSize,
+        sha256: opened.sha256,
+        body: opened.body,
+      });
+    },
+    async publishJson(spec) {
+      const parsed = parseJsonArtifact(spec);
+      const bytes = new TextEncoder().encode(stableJson(parsed.value));
+      return publish(input, {
+        ...parsed,
+        mediaType: "application/json",
+        byteSize: bytes.byteLength,
+        sha256: sha256(bytes),
+        body: new Blob([bytes]).stream(),
+      });
+    },
+  };
+}
+
+export function moduleWorkflowInputArtifactContext(
+  moduleName: string,
+  actorId: string,
+  storage: ModuleDurableStoragePort,
+  blobs: BlobStore | undefined,
+  durable: DurableHandlerContext,
+) {
+  return blobs
+    ? {
+        workflowInputArtifacts:
+          createModuleWorkflowInputArtifactPublicationPort({
+            moduleName,
+            actorId,
+            storage,
+            blobs,
+            durable,
+          }),
+      }
+    : {};
+}
+
+async function publish(
+  host: {
+    moduleName: string;
+    actorId: string;
+    blobs: BlobStore;
+    durable: DurableHandlerContext;
+  },
+  artifact: {
+    publicationKey: string;
+    kind: string;
+    filename: string;
+    retentionPolicyKey: string;
+    source: ModuleWorkflowInputArtifactSourceV1;
+    mediaType: string;
+    byteSize: number;
+    sha256: string;
+    body: ReadableStream<Uint8Array>;
+  },
+): Promise<AgentWorkflowArtifactRef> {
+  assertCoordinate(artifact);
+  if (!host.blobs.putOnce || !host.durable.publishArtifactOnce) {
+    throw unavailable();
+  }
+  const ref = artifactRef(
+    `blob_${sha256Text(
+      JSON.stringify([
+        host.durable.jobId,
+        host.durable.stageKey,
+        artifact.publicationKey,
+      ]),
+    ).slice(0, 32)}`,
+  );
+  const expectedContentHash: ContentHash = {
+    algorithm: "sha256",
+    value: artifact.sha256,
+  };
+  const stored = await host.blobs.putOnce({
+    ref,
+    body: artifact.body,
+    expectedByteSize: artifact.byteSize,
+    expectedContentHash,
+  });
+  const receipt = await host.durable.publishArtifactOnce(
+    artifact.publicationKey,
+    {
+      kind: artifact.kind,
+      artifactRef: stored.ref,
+      filename: artifact.filename,
+      contentType: artifact.mediaType,
+      byteSize: stored.byteSize,
+      sha256: stored.contentHash.value,
+      ownerId: host.actorId,
+      metadata: {
+        publicationKey: artifact.publicationKey,
+        retentionPolicyKey: artifact.retentionPolicyKey,
+        sourceModuleKey: host.moduleName,
+        sourceKind: artifact.source.kind,
+        sourceId: artifact.source.id,
+        sourceVersion: artifact.source.version,
+        sourceSequence: artifact.source.sequence,
+        ...(artifact.source.digest
+          ? { sourceDigest: artifact.source.digest }
+          : {}),
+      },
+    },
+  );
+  return {
+    artifactId: receipt.artifactId,
+    kind: artifact.kind,
+    mediaType: artifact.mediaType,
+    byteSize: stored.byteSize,
+    sha256: stored.contentHash.value,
+    retentionPolicyKey: artifact.retentionPolicyKey,
+    source: { moduleKey: host.moduleName, ...artifact.source },
+  };
+}
+
+function assertCoordinate(input: {
+  publicationKey: string;
+  kind: string;
+  filename: string;
+  retentionPolicyKey: string;
+  source: ModuleWorkflowInputArtifactSourceV1;
+}) {
+  const text = [
+    input.publicationKey,
+    input.kind,
+    input.filename,
+    input.retentionPolicyKey,
+    input.source.kind,
+    input.source.id,
+    input.source.version,
+  ];
+  if (
+    text.some((value) => !value.trim() || value !== value.trim()) ||
+    !Number.isSafeInteger(input.source.sequence) ||
+    input.source.sequence < 1
+  ) {
+    throw new DurableHandlerError(
+      "WORKFLOW_INPUT_ARTIFACT_INVALID",
+      "Workflow input artifact 坐标无效",
+      false,
+    );
+  }
+}
+
+function stableJson(value: JsonValue): string {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key]!)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function sha256(bytes: Uint8Array) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function sha256Text(value: string) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function unavailable() {
+  return new DurableHandlerError(
+    "WORKFLOW_INPUT_ARTIFACT_UNAVAILABLE",
+    "Workflow input artifact publication 未装配",
+    false,
+  );
+}
+
+function parseResource(value: unknown) {
+  try {
+    return parseModuleWorkflowInputResourceArtifactV1(value);
+  } catch {
+    throw invalid();
+  }
+}
+
+function parseJsonArtifact(value: unknown) {
+  try {
+    return parseModuleWorkflowInputJsonArtifactV1(value);
+  } catch {
+    throw invalid();
+  }
+}
+
+function invalid() {
+  return new DurableHandlerError(
+    "WORKFLOW_INPUT_ARTIFACT_INVALID",
+    "Workflow input artifact 输入无效",
+    false,
+  );
+}