create-windy 0.6.12 → 0.6.15

package/template/packages/ai-client/src/client-agent/workflow-artifact/contracts.ts

@@ -0,0 +1,85 @@
+import type { ClientAgentSessionGrant } from "../contracts.js";
+
+export const clientAgentWorkflowArtifactWorkIdPrefix = "cawa_" as const;
+
+export interface ClaimClientAgentWorkflowArtifactRequest {
+  readonly workflowRunId: string;
+  /** installation/conversation/tab/document epoch 的宿主 commitment。 */
+  readonly clientBindingDigest: `sha256:${string}`;
+}
+
+export interface AdvanceClientAgentWorkflowArtifactRequest<Result = unknown> {
+  readonly workId: string;
+  readonly claimToken: string;
+  readonly claimVersion: number;
+  /** 当前 claim 的完整、按序 Provider receipt 链。 */
+  readonly receiptIds: readonly string[];
+  readonly result?: Result;
+}
+
+export interface CancelClientAgentWorkflowArtifactRequest {
+  readonly workId: string;
+  readonly claimToken: string;
+  readonly claimVersion: number;
+}
+
+export type ClientAgentWorkflowArtifactStatus =
+  | "pending"
+  | "running"
+  | "completed"
+  | "cancelled";
+
+export const clientAgentWorkflowArtifactSafeCodes = [
+  "HOST_UNAVAILABLE",
+  "NO_PENDING_WORK",
+  "CLAIM_CONFLICT",
+  "WORK_NOT_FOUND",
+  "WORK_EXPIRED",
+  "WORK_CANCELLED",
+  "RECEIPT_REJECTED",
+  "ARTIFACT_REJECTED",
+  "INTERNAL_ERROR",
+] as const;
+
+export type ClientAgentWorkflowArtifactSafeCode =
+  (typeof clientAgentWorkflowArtifactSafeCodes)[number];
+
+export interface ClientAgentWorkflowArtifactSummary {
+  readonly artifactId: string;
+  readonly kind: string;
+  readonly contentType: string;
+  readonly filename: string;
+  readonly byteSize: number;
+  readonly sha256: string;
+}
+
+export type ClientAgentWorkflowJsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | readonly ClientAgentWorkflowJsonValue[]
+  | { readonly [key: string]: ClientAgentWorkflowJsonValue };
+
+export interface ClientAgentWorkflowExecutionTask {
+  readonly schemaVersion: 1;
+  readonly taskKey: string;
+  readonly input: ClientAgentWorkflowJsonValue;
+  readonly inputDigest: `sha256:${string}`;
+}
+
+/**
+ * Browser 只观察 claim lifecycle、短期 Client Agent grant 和最终 Artifact 摘要。
+ * Workflow Node/command、Scope、effect fence 与 Provider deployment 均不属于此 DTO。
+ */
+export interface ClientAgentWorkflowArtifactResponse {
+  readonly workId: string;
+  readonly status: ClientAgentWorkflowArtifactStatus;
+  readonly claimVersion: number;
+  /** 仅 running claim 返回；绑定当前 installation/session 与 claimVersion。 */
+  readonly claimToken?: string;
+  readonly sessionGrant?: ClientAgentSessionGrant;
+  readonly task?: ClientAgentWorkflowExecutionTask;
+  readonly artifact?: ClientAgentWorkflowArtifactSummary;
+  readonly safeCode?: ClientAgentWorkflowArtifactSafeCode;
+}

package/template/packages/ai-client/src/client-agent/workflow-artifact/http.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import {
+  clientAgentWorkflowArtifactAdvanceRequest,
+  clientAgentWorkflowArtifactClaimRequest,
+} from "./http.js";
+
+describe("Client Agent Workflow Artifact HTTP contract", () => {
+  test("Web Cookie 与 Extension 复用同一 claim route", () => {
+    const body = {
+      workflowRunId: "workflow-run-1",
+      clientBindingDigest: `sha256:${"a".repeat(64)}` as const,
+    };
+    const web = clientAgentWorkflowArtifactClaimRequest(body, {
+      mode: "current-session",
+    });
+    const extension = clientAgentWorkflowArtifactClaimRequest(body, {
+      mode: "paired-extension",
+      accessToken: "bax_installation-session",
+    });
+
+    expect(web.url).toBe(extension.url);
+    expect(web.init.credentials).toBe("same-origin");
+    expect(web.init.headers).toEqual({ "content-type": "application/json" });
+    expect(extension.init.credentials).toBe("omit");
+    expect(extension.init.headers).toEqual({
+      "content-type": "application/json",
+      authorization: "Bearer bax_installation-session",
+    });
+  });
+
+  test("advance 只发送 opaque claim 与完整 receipt 链", () => {
+    const request = clientAgentWorkflowArtifactAdvanceRequest(
+      {
+        workId: `cawa_${"w".repeat(32)}`,
+        claimToken: `cawc_${"c".repeat(32)}`,
+        claimVersion: 2,
+        receiptIds: ["receipt_0001"],
+        result: { summary: "研判完成" },
+      },
+      { mode: "current-session" },
+    );
+    const serialized = String(request.init.body);
+
+    expect(serialized).not.toContain("workflowRunId");
+    expect(serialized).not.toContain("nodeRunId");
+    expect(serialized).not.toContain("providerUrl");
+    expect(serialized).not.toContain("fenceToken");
+  });
+});

package/template/packages/ai-client/src/client-agent/workflow-artifact/http.ts

@@ -0,0 +1,82 @@
+import type {
+  AdvanceClientAgentWorkflowArtifactRequest,
+  CancelClientAgentWorkflowArtifactRequest,
+  ClaimClientAgentWorkflowArtifactRequest,
+} from "./contracts.js";
+
+export const clientAgentWorkflowArtifactHttp = {
+  claim: "/api/agent/client-workflow-artifacts/claim",
+  advance: "/api/agent/client-workflow-artifacts/advance",
+  cancel: "/api/agent/client-workflow-artifacts/cancel",
+} as const;
+
+export type ClientAgentWorkflowArtifactHostAuthentication =
+  | { readonly mode: "current-session" }
+  | {
+      readonly mode: "paired-extension";
+      readonly accessToken: `bax_${string}`;
+    };
+
+export function clientAgentWorkflowArtifactClaimRequest(
+  body: ClaimClientAgentWorkflowArtifactRequest,
+  authentication: ClientAgentWorkflowArtifactHostAuthentication,
+  signal?: AbortSignal,
+): { url: string; init: RequestInit } {
+  return jsonRequest(
+    clientAgentWorkflowArtifactHttp.claim,
+    body,
+    authentication,
+    signal,
+  );
+}
+
+export function clientAgentWorkflowArtifactAdvanceRequest<Result>(
+  body: AdvanceClientAgentWorkflowArtifactRequest<Result>,
+  authentication: ClientAgentWorkflowArtifactHostAuthentication,
+  signal?: AbortSignal,
+): { url: string; init: RequestInit } {
+  return jsonRequest(
+    clientAgentWorkflowArtifactHttp.advance,
+    body,
+    authentication,
+    signal,
+  );
+}
+
+export function clientAgentWorkflowArtifactCancelRequest(
+  body: CancelClientAgentWorkflowArtifactRequest,
+  authentication: ClientAgentWorkflowArtifactHostAuthentication,
+  signal?: AbortSignal,
+): { url: string; init: RequestInit } {
+  return jsonRequest(
+    clientAgentWorkflowArtifactHttp.cancel,
+    body,
+    authentication,
+    signal,
+  );
+}
+
+function jsonRequest(
+  url: string,
+  body: unknown,
+  authentication: ClientAgentWorkflowArtifactHostAuthentication,
+  signal?: AbortSignal,
+): { url: string; init: RequestInit } {
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+  };
+  if (authentication.mode === "paired-extension") {
+    headers.authorization = `Bearer ${authentication.accessToken}`;
+  }
+  return {
+    url,
+    init: {
+      method: "POST",
+      headers,
+      credentials:
+        authentication.mode === "current-session" ? "same-origin" : "omit",
+      body: JSON.stringify(body),
+      ...(signal ? { signal } : {}),
+    },
+  };
+}

package/template/packages/ai-client/src/client-agent/workflow-artifact/index.ts

@@ -0,0 +1,3 @@
+export * from "./contracts.js";
+export * from "./http.js";
+export * from "./validation.js";

package/template/packages/ai-client/src/client-agent/workflow-artifact/validation.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from "bun:test";
+import {
+  ClientAgentWorkflowArtifactContractError,
+  parseAdvanceClientAgentWorkflowArtifactRequest,
+  parseCancelClientAgentWorkflowArtifactRequest,
+  parseClientAgentWorkflowArtifactResponse,
+} from "./validation.js";
+
+describe("Client Agent Workflow Artifact validation", () => {
+  test("接受短期 grant 与最终 Artifact 安全摘要", () => {
+    const running = parseClientAgentWorkflowArtifactResponse({
+      workId: workId(),
+      status: "running",
+      claimVersion: 1,
+      claimToken: "cawc_12345678",
+      sessionGrant: grant(),
+      task: task(),
+    });
+    const completed = parseClientAgentWorkflowArtifactResponse({
+      workId: workId(),
+      status: "completed",
+      claimVersion: 1,
+      artifact: {
+        artifactId: "artifact_0001",
+        kind: "analysis-report",
+        contentType: "application/json",
+        filename: "analysis.json",
+        byteSize: 1024,
+        sha256: "d".repeat(64),
+      },
+    });
+
+    expect(running.sessionGrant?.sessionId).toBe("cas_1");
+    expect(completed.artifact?.filename).toBe("analysis.json");
+  });
+
+  test("拒绝 advance 注入内部 Workflow 或 Provider 坐标", () => {
+    expect(() =>
+      parseAdvanceClientAgentWorkflowArtifactRequest({
+        ...advance(),
+        workflowRunId: "workflow-run-1",
+      }),
+    ).toThrow("advance.workflowRunId 不允许");
+    expect(() =>
+      parseAdvanceClientAgentWorkflowArtifactRequest({
+        ...advance(),
+        providerUrl: "https://provider.example",
+      }),
+    ).toThrow(ClientAgentWorkflowArtifactContractError);
+  });
+
+  test("拒绝 claim token/receipt chain 与终态投影漂移", () => {
+    expect(() =>
+      parseAdvanceClientAgentWorkflowArtifactRequest({
+        ...advance(),
+        claimToken: "workflow-command-1",
+      }),
+    ).toThrow("claimToken 无效");
+    expect(() =>
+      parseAdvanceClientAgentWorkflowArtifactRequest({
+        ...advance(),
+        receiptIds: ["receipt_0001", "receipt_0001"],
+      }),
+    ).toThrow("receiptIds 不能重复");
+    expect(() =>
+      parseClientAgentWorkflowArtifactResponse({
+        workId: workId(),
+        status: "completed",
+        claimVersion: 1,
+      }),
+    ).toThrow("completed response 缺少 artifact");
+    expect(() =>
+      parseClientAgentWorkflowArtifactResponse({
+        workId: workId(),
+        status: "running",
+        claimVersion: 1,
+        claimToken: "cawc_12345678",
+        sessionGrant: { ...grant(), providerUrl: "https://provider.example" },
+        task: task(),
+      }),
+    ).toThrow("sessionGrant.providerUrl 不允许");
+    expect(() =>
+      parseCancelClientAgentWorkflowArtifactRequest({
+        workId: workId(),
+        claimToken: "cawc_12345678",
+        claimVersion: 0,
+      }),
+    ).toThrow("claimVersion 必须是正整数");
+  });
+
+  test("canonical task envelope 严格拒绝未知字段与非 JSON 输入", () => {
+    expect(() =>
+      parseClientAgentWorkflowArtifactResponse({
+        workId: workId(),
+        status: "running",
+        claimVersion: 1,
+        claimToken: "cawc_12345678",
+        sessionGrant: grant(),
+        task: { ...task(), rawArtifact: { secret: true } },
+      }),
+    ).toThrow("task.rawArtifact 不允许");
+  });
+
+  test("pending 投影使用尚未领取的 generation 0", () => {
+    expect(
+      parseClientAgentWorkflowArtifactResponse({
+        workId: workId(),
+        status: "pending",
+        claimVersion: 0,
+      }).claimVersion,
+    ).toBe(0);
+  });
+});
+
+function workId() {
+  return `cawa_${"w".repeat(32)}`;
+}
+
+function advance() {
+  return {
+    workId: workId(),
+    claimToken: `cawc_${"c".repeat(32)}`,
+    claimVersion: 1,
+    receiptIds: ["receipt_0001"],
+  };
+}
+
+function grant() {
+  return {
+    clientRunId: "carun_1",
+    sessionId: "cas_1",
+    trustedBaseUrl: "https://windy.example/api/agent/client-sessions/cas_1/v1/",
+    modelAlias: "windy-client-agent-v1",
+    limits: {
+      maxSteps: 8,
+      maxRequestBytes: 65_536,
+      maxResponseBytes: 65_536,
+      maxDurationSeconds: 60,
+      maxConcurrentRequests: 1,
+    },
+    expiresAt: "2026-08-28T10:00:00.000Z",
+    accessToken: `car_${"a".repeat(43)}`,
+    capabilities: ["pageAgentClientRun"],
+  };
+}
+
+function task() {
+  return {
+    schemaVersion: 1,
+    taskKey: "sharp.full-case.client-agent",
+    input: { artifactLocator: "case/clue.json" },
+    inputDigest: `sha256:${"f".repeat(64)}`,
+  };
+}

package/template/packages/ai-client/src/client-agent/workflow-artifact/validation.ts

@@ -0,0 +1,332 @@
+import { parseClientAgentSessionGrant } from "../validation.js";
+import {
+  clientAgentWorkflowArtifactSafeCodes,
+  clientAgentWorkflowArtifactWorkIdPrefix,
+  type AdvanceClientAgentWorkflowArtifactRequest,
+  type CancelClientAgentWorkflowArtifactRequest,
+  type ClaimClientAgentWorkflowArtifactRequest,
+  type ClientAgentWorkflowArtifactResponse,
+  type ClientAgentWorkflowArtifactSafeCode,
+  type ClientAgentWorkflowArtifactStatus,
+  type ClientAgentWorkflowArtifactSummary,
+  type ClientAgentWorkflowExecutionTask,
+  type ClientAgentWorkflowJsonValue,
+} from "./contracts.js";
+
+export class ClientAgentWorkflowArtifactContractError extends TypeError {
+  constructor(message: string) {
+    super(message);
+    this.name = "ClientAgentWorkflowArtifactContractError";
+  }
+}
+
+export function parseClaimClientAgentWorkflowArtifactRequest(
+  value: unknown,
+): ClaimClientAgentWorkflowArtifactRequest {
+  const input = strictObject(value, "claim", [
+    "workflowRunId",
+    "clientBindingDigest",
+  ]);
+  return {
+    workflowRunId: text(input.workflowRunId, "workflowRunId"),
+    clientBindingDigest: digest(
+      input.clientBindingDigest,
+      "clientBindingDigest",
+    ),
+  };
+}
+
+export function parseAdvanceClientAgentWorkflowArtifactRequest<
+  Result = unknown,
+>(value: unknown): AdvanceClientAgentWorkflowArtifactRequest<Result> {
+  const input = strictObject(value, "advance", [
+    "workId",
+    "claimToken",
+    "claimVersion",
+    "receiptIds",
+    "result",
+  ]);
+  return {
+    workId: workId(input.workId),
+    claimToken: claimToken(input.claimToken),
+    claimVersion: positive(input.claimVersion, "claimVersion"),
+    receiptIds: receiptIds(input.receiptIds),
+    ...(input.result === undefined ? {} : { result: input.result as Result }),
+  };
+}
+
+export function parseCancelClientAgentWorkflowArtifactRequest(
+  value: unknown,
+): CancelClientAgentWorkflowArtifactRequest {
+  const input = strictObject(value, "cancel", [
+    "workId",
+    "claimToken",
+    "claimVersion",
+  ]);
+  return {
+    workId: workId(input.workId),
+    claimToken: claimToken(input.claimToken),
+    claimVersion: positive(input.claimVersion, "claimVersion"),
+  };
+}
+
+export function parseClientAgentWorkflowArtifactResponse(
+  value: unknown,
+): ClientAgentWorkflowArtifactResponse {
+  const input = strictObject(value, "response", [
+    "workId",
+    "status",
+    "claimVersion",
+    "claimToken",
+    "sessionGrant",
+    "task",
+    "artifact",
+    "safeCode",
+  ]);
+  const status = workflowStatus(input.status);
+  const sessionGrant =
+    input.sessionGrant === undefined
+      ? undefined
+      : strictSessionGrant(input.sessionGrant);
+  const token =
+    input.claimToken === undefined ? undefined : claimToken(input.claimToken);
+  const artifact =
+    input.artifact === undefined ? undefined : artifactSummary(input.artifact);
+  const task = input.task === undefined ? undefined : executionTask(input.task);
+  assertProjection(status, token, sessionGrant, task, artifact);
+  return {
+    workId: workId(input.workId),
+    status,
+    claimVersion: nonNegative(input.claimVersion, "claimVersion"),
+    ...(token ? { claimToken: token } : {}),
+    ...(sessionGrant ? { sessionGrant } : {}),
+    ...(task ? { task } : {}),
+    ...(artifact ? { artifact } : {}),
+    ...(input.safeCode === undefined
+      ? {}
+      : { safeCode: safeCode(input.safeCode) }),
+  };
+}
+
+function executionTask(value: unknown): ClientAgentWorkflowExecutionTask {
+  const task = strictObject(value, "task", [
+    "schemaVersion",
+    "taskKey",
+    "input",
+    "inputDigest",
+  ]);
+  if (task.schemaVersion !== 1) invalid("task.schemaVersion 无效");
+  const taskKey = text(task.taskKey, "task.taskKey");
+  if (!/^[a-z0-9][a-z0-9._-]*$/u.test(taskKey)) {
+    invalid("task.taskKey 无效");
+  }
+  const input = jsonValue(task.input, "task.input");
+  if (new TextEncoder().encode(JSON.stringify(input)).byteLength > 256 * 1024) {
+    invalid("task.input 过大");
+  }
+  return {
+    schemaVersion: 1,
+    taskKey,
+    input,
+    inputDigest: digest(task.inputDigest, "task.inputDigest"),
+  };
+}
+
+function strictSessionGrant(value: unknown) {
+  const grant = strictObject(value, "sessionGrant", [
+    "clientRunId",
+    "sessionId",
+    "trustedBaseUrl",
+    "modelAlias",
+    "limits",
+    "expiresAt",
+    "accessToken",
+    "capabilities",
+  ]);
+  strictObject(grant.limits, "sessionGrant.limits", [
+    "maxSteps",
+    "maxRequestBytes",
+    "maxResponseBytes",
+    "maxDurationSeconds",
+    "maxConcurrentRequests",
+  ]);
+  return parseClientAgentSessionGrant(grant);
+}
+
+function artifactSummary(value: unknown): ClientAgentWorkflowArtifactSummary {
+  const artifact = strictObject(value, "artifact", [
+    "artifactId",
+    "kind",
+    "contentType",
+    "filename",
+    "byteSize",
+    "sha256",
+  ]);
+  const filename = text(artifact.filename, "artifact.filename");
+  if (filename.includes("/") || filename.includes("\\")) {
+    invalid("artifact.filename 无效");
+  }
+  return {
+    artifactId: opaque(artifact.artifactId, "artifact.artifactId"),
+    kind: text(artifact.kind, "artifact.kind"),
+    contentType: text(artifact.contentType, "artifact.contentType"),
+    filename,
+    byteSize: nonNegative(artifact.byteSize, "artifact.byteSize"),
+    sha256: hexDigest(artifact.sha256, "artifact.sha256"),
+  };
+}
+
+function assertProjection(
+  status: ClientAgentWorkflowArtifactStatus,
+  token: unknown,
+  sessionGrant: unknown,
+  task: unknown,
+  artifact: unknown,
+) {
+  if (status === "running" && (!token || !sessionGrant || !task)) {
+    invalid("running response 缺少 claimToken、sessionGrant 或 task");
+  }
+  if (status === "completed" && !artifact) {
+    invalid("completed response 缺少 artifact");
+  }
+  if (status !== "running" && (token || sessionGrant || task)) {
+    invalid("只有 running response 可以包含 claimToken、sessionGrant 和 task");
+  }
+  if (status !== "completed" && artifact) {
+    invalid("只有 completed response 可以包含 artifact");
+  }
+}
+
+function jsonValue(
+  value: unknown,
+  label: string,
+  depth = 0,
+): ClientAgentWorkflowJsonValue {
+  if (depth > 32) invalid(`${label} 嵌套过深`);
+  if (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean" ||
+    (typeof value === "number" && Number.isFinite(value))
+  ) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => jsonValue(item, label, depth + 1));
+  }
+  if (value && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    return Object.fromEntries(
+      Object.entries(record).map(([key, item]) => [
+        key,
+        jsonValue(item, `${label}.${key}`, depth + 1),
+      ]),
+    );
+  }
+  invalid(`${label} 不是 JSON`);
+}
+
+function workflowStatus(value: unknown): ClientAgentWorkflowArtifactStatus {
+  if (
+    value !== "pending" &&
+    value !== "running" &&
+    value !== "completed" &&
+    value !== "cancelled"
+  ) {
+    invalid("status 无效");
+  }
+  return value;
+}
+
+function safeCode(value: unknown): ClientAgentWorkflowArtifactSafeCode {
+  if (!clientAgentWorkflowArtifactSafeCodes.includes(value as never)) {
+    invalid("safeCode 无效");
+  }
+  return value as ClientAgentWorkflowArtifactSafeCode;
+}
+
+function receiptIds(value: unknown): readonly string[] {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 128) {
+    invalid("receiptIds 无效");
+  }
+  const parsed = value.map((item) => opaque(item, "receiptId"));
+  if (new Set(parsed).size !== parsed.length) invalid("receiptIds 不能重复");
+  return parsed;
+}
+
+function workId(value: unknown): string {
+  return prefixedOpaque(
+    value,
+    "workId",
+    clientAgentWorkflowArtifactWorkIdPrefix,
+  );
+}
+
+function claimToken(value: unknown): string {
+  return prefixedOpaque(value, "claimToken", "cawc_");
+}
+
+function prefixedOpaque(value: unknown, label: string, prefix: string): string {
+  const parsed = opaque(value, label);
+  if (!parsed.startsWith(prefix)) invalid(`${label} 无效`);
+  return parsed;
+}
+
+function opaque(value: unknown, label: string): string {
+  const parsed = text(value, label);
+  if (!/^[A-Za-z0-9_-]{8,512}$/u.test(parsed)) invalid(`${label} 无效`);
+  return parsed;
+}
+
+function strictObject(
+  value: unknown,
+  label: string,
+  allowedKeys: readonly string[],
+): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    invalid(`${label} 必须是对象`);
+  }
+  const record = value as Record<string, unknown>;
+  const unknownKey = Object.keys(record).find(
+    (key) => !allowedKeys.includes(key),
+  );
+  if (unknownKey) invalid(`${label}.${unknownKey} 不允许`);
+  return record;
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== "string" || !value.trim() || value.length > 512) {
+    invalid(`${label} 无效`);
+  }
+  return value;
+}
+
+function positive(value: unknown, label: string): number {
+  if (!Number.isSafeInteger(value) || Number(value) <= 0) {
+    invalid(`${label} 必须是正整数`);
+  }
+  return Number(value);
+}
+
+function nonNegative(value: unknown, label: string): number {
+  if (!Number.isSafeInteger(value) || Number(value) < 0) {
+    invalid(`${label} 必须是非负整数`);
+  }
+  return Number(value);
+}
+
+function digest(value: unknown, label: string): `sha256:${string}` {
+  const parsed = text(value, label);
+  if (!/^sha256:[a-f0-9]{64}$/u.test(parsed)) invalid(`${label} 无效`);
+  return parsed as `sha256:${string}`;
+}
+
+function hexDigest(value: unknown, label: string): string {
+  const parsed = text(value, label);
+  if (!/^[a-f0-9]{64}$/u.test(parsed)) invalid(`${label} 无效`);
+  return parsed;
+}
+
+function invalid(message: string): never {
+  throw new ClientAgentWorkflowArtifactContractError(message);
+}