create-windy 0.6.12 → 0.6.15

package/template/packages/shared/src/agent-workflow-run.ts

@@ -0,0 +1,259 @@
+import type { JsonValue } from "./json.js";
+import type { ISODateTime } from "./primitives.js";
+import type { AgentWorkflowNodeType } from "./agent-workflow-definition.js";
+
+export interface AgentWorkflowBudget {
+  readonly maxDurationSeconds: number;
+  readonly maxModelAttempts: number;
+  readonly maxToolCalls: number;
+  readonly maxSubagents: number;
+  readonly maxParallelism: number;
+  readonly maxInputTokens: number;
+  readonly maxOutputTokens: number;
+  readonly maxCostMicros: number;
+}
+
+export interface AgentWorkflowArtifactRef {
+  readonly artifactId: string;
+  readonly kind: string;
+  readonly mediaType: string;
+  readonly byteSize: number;
+  readonly sha256: string;
+  readonly retentionPolicyKey: string;
+  readonly source: {
+    readonly moduleKey: string;
+    readonly kind: string;
+    readonly id: string;
+    readonly version: string;
+    readonly sequence: number;
+    readonly digest?: string;
+  };
+}
+
+export type AgentWorkflowMeasuredCount =
+  | {
+      readonly status: "measured";
+      readonly value: number;
+      readonly source: "provider-reported" | "host-measured";
+    }
+  | { readonly status: "unknown"; readonly reasonCode: string };
+
+export type AgentWorkflowMeasuredCost =
+  | {
+      readonly status: "measured";
+      readonly amountMicros: number;
+      readonly currency: string;
+      readonly source:
+        | "provider-reported"
+        | "catalog-estimated"
+        | "host-measured";
+    }
+  | { readonly status: "unknown"; readonly reasonCode: string };
+
+export interface AgentWorkflowUsage {
+  readonly durationMs: number;
+  readonly modelAttempts: number;
+  readonly toolCalls: number;
+  readonly subagents: number;
+  readonly inputTokens: AgentWorkflowMeasuredCount;
+  readonly outputTokens: AgentWorkflowMeasuredCount;
+  readonly cost: AgentWorkflowMeasuredCost;
+}
+
+export interface AgentWorkflowInputReceipt {
+  readonly schemaKey: string;
+  readonly value: JsonValue;
+  readonly valueDigest: string;
+  readonly recordedAt: ISODateTime;
+}
+
+export type AgentWorkflowRunStatus =
+  | "accepted"
+  | "running"
+  | "waiting"
+  | "completed"
+  | "failed"
+  | "cancelled"
+  | "timed-out";
+export type AgentWorkflowNodeRunStatus =
+  | "pending"
+  | "ready"
+  | "running"
+  | "waiting"
+  | "retry-scheduled"
+  | "completed"
+  | "failed"
+  | "cancelled"
+  | "skipped"
+  | "timed-out";
+
+export interface AgentWorkflowRun {
+  readonly runId: string;
+  readonly releaseId: string;
+  readonly tenantId: string;
+  readonly actorId: string;
+  readonly routeKey: string;
+  readonly inputDigest: string;
+  readonly inputReceipt: AgentWorkflowInputReceipt;
+  readonly scopeDigest: string;
+  readonly authorizationSnapshotDigest: string;
+  readonly toolPolicyDigest: string;
+  readonly workspacePolicyDigest: string;
+  readonly executionPolicyDigest: string;
+  readonly status: AgentWorkflowRunStatus;
+  readonly budget: AgentWorkflowBudget;
+  readonly usage: AgentWorkflowUsage;
+  readonly deadlineAt: ISODateTime;
+  readonly sessionId?: string;
+  readonly parentRunId?: string;
+  readonly parentNodeId?: string;
+  readonly parentNodeRunId?: string;
+  readonly cancellationRequestedAt?: ISODateTime;
+  readonly createdAt: ISODateTime;
+  readonly updatedAt: ISODateTime;
+  readonly finishedAt?: ISODateTime;
+  readonly version: number;
+  readonly safeErrorCode?: string;
+}
+
+export interface AgentWorkflowNodeResultReceipt {
+  readonly receiptId: string;
+  readonly nodeRunId: string;
+  readonly resultDigest: string;
+  readonly outputSchemaKey?: string;
+  readonly selectedBranch?: string;
+  readonly smallResult?: JsonValue;
+  readonly executionEvidence?: {
+    readonly source: "agent-runtime-report";
+    readonly agentRunId: string;
+    readonly modelRouteKey: string;
+    readonly model: string;
+    readonly modelDeploymentDigest: string;
+    readonly modelConfigurationDigest: string;
+  };
+  readonly artifactIds: readonly string[];
+  readonly recordedAt: ISODateTime;
+}
+
+export interface AgentWorkflowNodeRun {
+  readonly nodeRunId: string;
+  readonly runId: string;
+  readonly nodeId: string;
+  readonly previousNodeRunId?: string;
+  readonly nodeType: AgentWorkflowNodeType;
+  readonly status: AgentWorkflowNodeRunStatus;
+  readonly attempt: number;
+  readonly maxAttempts: number;
+  readonly idempotencyKey: string;
+  readonly adapter?: {
+    readonly kind:
+      | "model-operation"
+      | "agent-tool"
+      | "child-agent"
+      | "approval-work-item"
+      | "durable-job"
+      | "wait-signal"
+      | "artifact-store"
+      | "finalizer";
+    readonly coordinate: string;
+  };
+  readonly inputArtifacts: readonly AgentWorkflowArtifactRef[];
+  readonly outputArtifacts: readonly AgentWorkflowArtifactRef[];
+  readonly resultReceipt?: AgentWorkflowNodeResultReceipt;
+  readonly safeErrorCode?: string;
+  readonly createdAt: ISODateTime;
+  readonly updatedAt: ISODateTime;
+  readonly startedAt?: ISODateTime;
+  readonly finishedAt?: ISODateTime;
+  readonly version: number;
+}
+
+export function isAgentWorkflowTerminal(
+  status: AgentWorkflowRunStatus,
+): boolean {
+  return ["completed", "failed", "cancelled", "timed-out"].includes(status);
+}
+
+export function isAgentWorkflowNodeTerminal(
+  status: AgentWorkflowNodeRunStatus,
+): boolean {
+  return ["completed", "failed", "cancelled", "skipped", "timed-out"].includes(
+    status,
+  );
+}
+
+export function isAgentWorkflowRunTransitionAllowed(
+  from: AgentWorkflowRunStatus,
+  to: AgentWorkflowRunStatus,
+): boolean {
+  const allowed: Record<
+    AgentWorkflowRunStatus,
+    readonly AgentWorkflowRunStatus[]
+  > = {
+    accepted: ["running", "cancelled", "timed-out", "failed"],
+    running: ["waiting", "completed", "failed", "cancelled", "timed-out"],
+    waiting: ["running", "failed", "cancelled", "timed-out"],
+    completed: [],
+    failed: [],
+    cancelled: [],
+    "timed-out": [],
+  };
+  return allowed[from].includes(to);
+}
+
+export function isAgentWorkflowNodeTransitionAllowed(
+  from: AgentWorkflowNodeRunStatus,
+  to: AgentWorkflowNodeRunStatus,
+): boolean {
+  const allowed: Record<
+    AgentWorkflowNodeRunStatus,
+    readonly AgentWorkflowNodeRunStatus[]
+  > = {
+    pending: ["ready", "skipped", "cancelled", "timed-out"],
+    ready: ["running", "cancelled", "timed-out"],
+    running: [
+      "waiting",
+      "completed",
+      "failed",
+      "cancelled",
+      "skipped",
+      "timed-out",
+    ],
+    waiting: [
+      "running",
+      "completed",
+      "failed",
+      "cancelled",
+      "skipped",
+      "timed-out",
+    ],
+    failed: ["retry-scheduled"],
+    "retry-scheduled": ["cancelled", "timed-out"],
+    completed: [],
+    cancelled: [],
+    skipped: [],
+    "timed-out": [],
+  };
+  return allowed[from].includes(to);
+}
+
+export function usageFitsWithinBudget(
+  usage: AgentWorkflowUsage,
+  budget: AgentWorkflowBudget,
+): boolean {
+  if (
+    usage.inputTokens.status !== "measured" ||
+    usage.outputTokens.status !== "measured" ||
+    usage.cost.status !== "measured"
+  )
+    return false;
+  return (
+    usage.durationMs <= budget.maxDurationSeconds * 1_000 &&
+    usage.modelAttempts <= budget.maxModelAttempts &&
+    usage.toolCalls <= budget.maxToolCalls &&
+    usage.subagents <= budget.maxSubagents &&
+    usage.inputTokens.value <= budget.maxInputTokens &&
+    usage.outputTokens.value <= budget.maxOutputTokens &&
+    usage.cost.amountMicros <= budget.maxCostMicros
+  );
+}

package/template/packages/shared/src/agent-workflow.ts

@@ -0,0 +1,3 @@
+export * from "./agent-workflow-definition.js";
+export * from "./agent-workflow-run.js";
+export * from "./agent-workflow-delegation.js";

package/template/packages/shared/src/ai-runtime-report.ts

@@ -107,6 +107,8 @@ export interface AiRuntimeRunModelDeployment {
 
 export interface AiRuntimeRunListItem {
   runId: string;
+  /** 创建该 Run 的稳定 Engine 实现标识；历史 ADK Run 保持原值。 */
+  engineId: string;
   operationKey: string;
   actor: AiRuntimeActorSummary | null;
   status: AiRuntimeRunStatus;
@@ -142,11 +144,34 @@ export interface AiRuntimeAttemptDetail extends AiRuntimeRunUsage {
   finishedAt: ISODateTime | null;
 }
 
+export interface AiRuntimeTrajectoryEvent {
+  sequence: number;
+  sequenceEnd: number;
+  type: string;
+  title: string;
+  toolKey?: string;
+  approvalOutcome?: string;
+  attemptSequence?: number;
+  totalTokens?: number;
+  artifactCount?: number;
+  inputModalities?: string[];
+  deltaCount?: number;
+  outputCharacters?: number;
+  errorCode?: string;
+}
+
+export interface AiRuntimeTrajectory {
+  /** canonical Run 超过既有留存期后，报表仍可读但轨迹不再可用。 */
+  available: boolean;
+  events: AiRuntimeTrajectoryEvent[];
+}
+
 export interface AiRuntimeRunDetail extends AiRuntimeRunListItem {
   releaseId: string;
   traceId: string;
   safeErrorCode: string | null;
   attempts: AiRuntimeAttemptDetail[];
+  trajectory: AiRuntimeTrajectory;
 }
 
 export type AiRuntimeRunPage = PageResult<AiRuntimeRunListItem>;

package/template/packages/shared/src/rbac.ts

@@ -69,6 +69,30 @@ export interface AgentRunAuthorizationSnapshot {
   featureKey: string;
   allowedToolKeys: string[];
   toolNetworkMode: "forbidden";
+  /** Host-normalized current Case coordinate; absent forbids Case Memory. */
+  memoryScopeCaseId?: string;
+  // @windy-module system.agent begin
+  /** Workflow-only: binds the narrowed runtime budget to the Run grant. */
+  runtimeBudgetDigest?: string;
+  /** Workflow-only: frozen provider deployment and model used for this Run. */
+  modelPin?: {
+    deploymentKey: string;
+    model: string;
+  };
+  /** Child Agent only: immutable effective delegation ceiling. */
+  delegation?: {
+    delegationId: string;
+    policyDigest: string;
+    budgetDigest: string;
+    workspaceId: string;
+    workspacePolicyKey: string;
+    scopeDigest: string;
+    scopePolicyDigest: string;
+    capabilityKey: string;
+    requiredFeatureKeys: string[];
+    requiredPermissionKeys: string[];
+  };
+  // @windy-module system.agent end
 }
 
 export type CredentialState = "active" | "must-change-password";

package/template/packages/storage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/storage",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/storage/src/blob-store-put-once.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { artifactRef, BlobStoreError } from "./blob-store.js";
+import { LocalFileBlobStore } from "./local-file-blob-store.js";
+import { MemoryBlobStore } from "./memory-blob-store.js";
+
+const roots: string[] = [];
+const stableRef = artifactRef(`blob_${"1".repeat(32)}`);
+
+afterEach(async () => {
+  await Promise.all(
+    roots.splice(0).map((root) => rm(root, { recursive: true })),
+  );
+});
+
+describe("BlobStore putOnce", () => {
+  test("Memory exact replay 返回同一 ref，内容漂移 fail closed", async () => {
+    const store = new MemoryBlobStore();
+    const first = await store.putOnce!(input("same"));
+    const replay = await store.putOnce!(input("same"));
+    expect(replay.ref).toBe(first.ref);
+    await expect(store.putOnce!(input("drift"))).rejects.toMatchObject({
+      code: "BLOB_IDENTITY_CONFLICT",
+    } satisfies Partial<BlobStoreError>);
+  });
+
+  test("Local 并发 exact replay 只发布一个稳定 Blob", async () => {
+    const store = await localStore();
+    const [left, right] = await Promise.all([
+      store.putOnce!(input("same")),
+      store.putOnce!(input("same")),
+    ]);
+    expect(left.ref).toBe(stableRef);
+    expect(right.ref).toBe(stableRef);
+  });
+
+  test("Local blob-only commit unknown 可按同内容补 seal", async () => {
+    const { store, root } = await localStoreWithRoot();
+    const directory = join(root, "blobs", stableRef.slice(5, 7));
+    await mkdir(directory, { recursive: true });
+    await writeFile(join(directory, `${stableRef}.blob`), "same");
+    expect((await store.putOnce!(input("same"))).ref).toBe(stableRef);
+  });
+});
+
+function input(value: string) {
+  const bytes = new TextEncoder().encode(value);
+  return {
+    ref: stableRef,
+    body: new Blob([bytes]).stream(),
+    expectedByteSize: bytes.byteLength,
+    expectedContentHash: {
+      algorithm: "sha256" as const,
+      value: createHash("sha256").update(bytes).digest("hex"),
+    },
+  };
+}
+
+async function localStore() {
+  return (await localStoreWithRoot()).store;
+}
+
+async function localStoreWithRoot() {
+  const root = await mkdtemp(join(tmpdir(), "windy-blob-once-"));
+  roots.push(root);
+  return { root, store: new LocalFileBlobStore({ root }) };
+}

package/template/packages/storage/src/blob-store.ts

@@ -22,8 +22,16 @@ export interface PutBlobInput {
   expectedContentHash?: ContentHash;
 }
 
+export interface PutBlobOnceInput extends PutBlobInput {
+  readonly ref: ArtifactRef;
+  readonly expectedByteSize: number;
+  readonly expectedContentHash: ContentHash;
+}
+
 export interface BlobStore {
   put(input: PutBlobInput): Promise<StoredBlob>;
+  /** Exact replay returns the original Blob; coordinate or content drift fails closed. */
+  putOnce?(input: PutBlobOnceInput): Promise<StoredBlob>;
   inspect(ref: ArtifactRef): Promise<StoredBlob | undefined>;
   open(ref: ArtifactRef): Promise<ReadableBlob | undefined>;
   delete(ref: ArtifactRef): Promise<boolean>;
@@ -42,6 +50,7 @@ export type BlobStoreErrorCode =
   | "INVALID_CONTENT_HASH"
   | "SIZE_MISMATCH"
   | "HASH_MISMATCH"
+  | "BLOB_IDENTITY_CONFLICT"
   | "CORRUPT_BLOB_METADATA";
 
 export class BlobStoreError extends Error {

package/template/packages/storage/src/local-file-blob-put-once.ts

@@ -0,0 +1,120 @@
+import { link, open, stat, type FileHandle } from "node:fs/promises";
+import {
+  BlobStoreError,
+  type ArtifactRef,
+  type PutBlobOnceInput,
+  type StoredBlob,
+} from "./blob-store.js";
+import { createSha256Accumulator } from "./content-hash.js";
+import { writeLocalBlob } from "./local-file-blob-writer.js";
+
+export async function installBlobOnce(input: {
+  ref: ArtifactRef;
+  input: PutBlobOnceInput;
+  blob: string;
+  temporaryBlob: string;
+  now: () => Date;
+}): Promise<StoredBlob> {
+  if (await pathExists(input.blob)) return inspectUnsealedBlob(input);
+  const candidate = await writeLocalBlob(
+    input.temporaryBlob,
+    input.ref,
+    input.input,
+    input.now,
+  );
+  try {
+    await link(input.temporaryBlob, input.blob);
+    return candidate;
+  } catch (error) {
+    if (!isExists(error)) throw error;
+    return inspectUnsealedBlob(input);
+  }
+}
+
+export async function linkOnce(source: string, target: string) {
+  try {
+    await link(source, target);
+  } catch (error) {
+    if (!isExists(error)) throw error;
+  }
+}
+
+export function requireExactBlob(
+  stored: StoredBlob,
+  input: PutBlobOnceInput,
+): StoredBlob {
+  if (
+    stored.ref !== input.ref ||
+    stored.byteSize !== input.expectedByteSize ||
+    stored.contentHash.algorithm !== input.expectedContentHash.algorithm ||
+    stored.contentHash.value !== input.expectedContentHash.value
+  ) {
+    throw new BlobStoreError(
+      "BLOB_IDENTITY_CONFLICT",
+      `Blob 稳定坐标冲突：${input.ref}`,
+    );
+  }
+  return stored;
+}
+
+async function inspectUnsealedBlob(input: {
+  ref: ArtifactRef;
+  input: PutBlobOnceInput;
+  blob: string;
+  now: () => Date;
+}) {
+  const handle = await open(input.blob, "r");
+  try {
+    return requireExactBlob(
+      {
+        ref: input.ref,
+        byteSize: (await handle.stat()).size,
+        contentHash: { algorithm: "sha256", value: await hashHandle(handle) },
+        createdAt: input.now().toISOString(),
+      },
+      input.input,
+    );
+  } finally {
+    await handle.close();
+  }
+}
+
+async function hashHandle(handle: FileHandle): Promise<string> {
+  const hash = createSha256Accumulator();
+  const chunk = new Uint8Array(64 * 1024);
+  let position = 0;
+  while (true) {
+    const { bytesRead } = await handle.read(
+      chunk,
+      0,
+      chunk.byteLength,
+      position,
+    );
+    if (bytesRead === 0) break;
+    hash.update(chunk.subarray(0, bytesRead));
+    position += bytesRead;
+  }
+  return hash.digest().value;
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isCode(error, "ENOENT")) return false;
+    throw error;
+  }
+}
+
+function isExists(error: unknown) {
+  return isCode(error, "EEXIST");
+}
+
+function isCode(error: unknown, code: string) {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error as NodeJS.ErrnoException).code === code
+  );
+}

package/template/packages/storage/src/local-file-blob-store.ts

@@ -15,6 +15,7 @@ import {
   type ArtifactRef,
   type BlobStore,
   type PutBlobInput,
+  type PutBlobOnceInput,
   type ReadableBlob,
   type StoredBlob,
 } from "./blob-store.js";
@@ -23,6 +24,11 @@ import {
   validateExpectedSize,
   writeLocalBlob,
 } from "./local-file-blob-writer.js";
+import {
+  installBlobOnce,
+  linkOnce,
+  requireExactBlob,
+} from "./local-file-blob-put-once.js";
 
 export interface LocalFileBlobStoreOptions {
   root: string;
@@ -40,8 +46,54 @@ export class LocalFileBlobStore implements BlobStore {
   }
 
   async put(input: PutBlobInput): Promise<StoredBlob> {
+    return this.write(this.createRef(), input);
+  }
+
+  async putOnce(input: PutBlobOnceInput): Promise<StoredBlob> {
+    const ref = artifactRef(input.ref);
+    validateExpectedSize(input.expectedByteSize);
+    const paths = this.paths(ref);
+    await mkdir(paths.directory, { recursive: true });
+    await mkdir(paths.temporaryDirectory, { recursive: true });
+    const suffix = randomUUID();
+    const temporaryBlob = join(
+      paths.temporaryDirectory,
+      `${ref}.${suffix}.partial`,
+    );
+    const temporaryMetadata = join(
+      paths.temporaryDirectory,
+      `${ref}.${suffix}.json.partial`,
+    );
+    try {
+      const existing = await this.inspect(ref);
+      if (existing) return requireExactBlob(existing, input);
+      const stored = await installBlobOnce({
+        ref,
+        input,
+        blob: paths.blob,
+        temporaryBlob,
+        now: this.now,
+      });
+      await syncDirectory(paths.directory);
+      await writeDurably(temporaryMetadata, `${JSON.stringify(stored)}\n`);
+      await linkOnce(temporaryMetadata, paths.metadata);
+      await syncDirectory(paths.directory);
+      const committed = await this.inspect(ref);
+      if (!committed) throw corruptMetadata(ref);
+      return requireExactBlob(committed, input);
+    } finally {
+      await Promise.all([
+        rm(temporaryBlob, { force: true }),
+        rm(temporaryMetadata, { force: true }),
+      ]);
+    }
+  }
+
+  private async write(
+    ref: ArtifactRef,
+    input: PutBlobInput,
+  ): Promise<StoredBlob> {
     validateExpectedSize(input.expectedByteSize);
-    const ref = this.createRef();
     const paths = this.paths(ref);
     await mkdir(paths.directory, { recursive: true });
     await mkdir(paths.temporaryDirectory, { recursive: true });