create-windy 0.6.12 → 0.6.14

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.1",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/storage/src/upload-streams.test.ts

@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test";
+import { abortAwareStream } from "./upload-streams.js";
+
+test("兼容 Bun 缺少 releaseLock 和 cancel 的请求流实现", async () => {
+  const bodyWithoutReleaseLock = {
+    getReader: () => ({
+      read: async () => ({ done: true, value: undefined }),
+      cancel: async () => undefined,
+    }),
+  } as unknown as ReadableStream<Uint8Array>;
+  const completed = abortAwareStream(
+    bodyWithoutReleaseLock,
+    new AbortController().signal,
+  ).getReader();
+
+  await expect(completed.read()).resolves.toEqual({
+    done: true,
+    value: undefined,
+  });
+
+  const bodyWithoutCancel = {
+    getReader: () => ({
+      read: async () => ({ done: true, value: undefined }),
+      releaseLock: () => undefined,
+    }),
+  } as unknown as ReadableStream<Uint8Array>;
+
+  await expect(
+    abortAwareStream(bodyWithoutCancel, new AbortController().signal).cancel(),
+  ).resolves.toBeUndefined();
+});

package/template/packages/storage/src/upload-streams.ts

@@ -22,7 +22,7 @@ export function abortAwareStream(
           const result = await raceAbort(source.read(), signal);
           if (result.done) {
             finished = true;
-            source.releaseLock();
+            releaseReader(source);
             controller.close();
             return;
           }
@@ -40,7 +40,7 @@ export function abortAwareStream(
           await cancelReader(reader, reason);
           return;
         }
-        await body.cancel(reason).catch(() => undefined);
+        await cancelStream(body, reason);
       },
     },
     { highWaterMark: 0 },
@@ -69,7 +69,7 @@ export function concatBlobStreams(
         }
         const result = await current.read();
         if (result.done) {
-          current.releaseLock();
+          releaseReader(current);
           current = undefined;
           continue;
         }
@@ -101,7 +101,7 @@ export function guardFileSignature(
           while (prefixSize < requiredBytes) {
             const result = await source.read();
             if (result.done) {
-              source.releaseLock();
+              releaseReader(source);
               controller.error(signatureError());
               return;
             }
@@ -126,7 +126,7 @@ export function guardFileSignature(
         }
         const result = await source.read();
         if (result.done) {
-          source.releaseLock();
+          releaseReader(source);
           controller.close();
         } else {
           controller.enqueue(result.value);
@@ -137,7 +137,7 @@ export function guardFileSignature(
           await cancelReader(reader, reason);
           return;
         }
-        await body.cancel(reason).catch(() => undefined);
+        await cancelStream(body, reason);
       },
     },
     { highWaterMark: 0 },
@@ -217,3 +217,17 @@ async function cancelReader(
     }
   }
 }
+
+async function cancelStream(
+  stream: ReadableStream<Uint8Array>,
+  reason?: unknown,
+): Promise<void> {
+  const cancel = stream.cancel;
+  if (typeof cancel !== "function") return;
+  await cancel.call(stream, reason).catch(() => undefined);
+}
+
+function releaseReader(reader: ReadableStreamDefaultReader<Uint8Array>): void {
+  const releaseLock = reader.releaseLock;
+  if (typeof releaseLock === "function") releaseLock.call(reader);
+}

package/template/apps/agent-server/adk_web_agents/__init__.py

@@ -1 +0,0 @@
-"""Developer-only ADK Web agents."""

package/template/apps/agent-server/adk_web_agents/canonical_debug/__init__.py

@@ -1 +0,0 @@
-"""Developer-only canonical Run bridge for ADK Web."""

package/template/apps/agent-server/adk_web_agents/canonical_debug/agent.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import AsyncGenerator
-from typing import cast
-
-from google.adk.agents import LlmAgent
-from google.adk.models.base_llm import BaseLlm
-from google.adk.models.llm_request import LlmRequest
-from google.adk.models.llm_response import LlmResponse
-from google.adk.tools.tool_context import ToolContext
-from google.genai import types
-
-from southwind_agent_server.adk_debug import (
-    CanonicalRunDebugClient,
-    TextOperationDebugConfig,
-    load_text_operation_debug_config,
-)
-from southwind_agent_server.adk_debug_sessions import (
-    IMPORTED_SESSION_STATE_KEY,
-    ImportedDebugSessionReadOnlyError,
-)
-
-TOOL_NAME = "run_canonical_operation"
-PROJECT_OPERATION = load_text_operation_debug_config()
-
-
-async def run_canonical_operation(
-    question: str, tool_context: ToolContext
-) -> dict[str, object]:
-    """Run the project-selected text Operation through canonical platform APIs."""
-    ensure_debug_session_writable(tool_context.state.get(IMPORTED_SESSION_STATE_KEY))
-    if PROJECT_OPERATION is None:
-        raise RuntimeError("项目尚未选择可调试的文本 Operation")
-    return await CanonicalRunDebugClient.from_environment(
-        PROJECT_OPERATION.operation_key
-    ).run(question)
-
-
-def ensure_debug_session_writable(imported_marker: object) -> None:
-    if imported_marker is True:
-        raise ImportedDebugSessionReadOnlyError(
-            "导入的业务会话是实时只读投影；请新建本地会话继续提问"
-        )
-
-
-class CanonicalDebugLlm(BaseLlm):
-    """ADK dispatcher; real model and Tool execution stay in canonical Run."""
-
-    def __init__(self, operation: TextOperationDebugConfig | None) -> None:
-        super().__init__(model="windy-canonical-run-bridge")
-        self._operation = operation
-
-    async def generate_content_async(
-        self,
-        llm_request: LlmRequest,
-        stream: bool = False,
-    ) -> AsyncGenerator[LlmResponse, None]:
-        del stream
-        question, user_turn_index = latest_user_turn(llm_request)
-        tool_response = latest_tool_response(llm_request, user_turn_index)
-        if tool_response is not None:
-            yield text_response(render_result(tool_response))
-            return
-        if self._operation is None:
-            yield text_response(
-                "项目尚未在 apps/agent-server/project/adk-web-debug.json "
-                "选择真实文本 Operation。"
-            )
-            return
-        if not question:
-            yield text_response("请输入要交给真实 Agent Runtime 调试的业务问题。")
-            return
-        yield LlmResponse(
-            content=types.Content(
-                role="model",
-                parts=[
-                    types.Part(
-                        function_call=types.FunctionCall(
-                            name=TOOL_NAME,
-                            args={"question": question},
-                        )
-                    )
-                ],
-            ),
-            partial=False,
-        )
-
-
-def latest_user_turn(request: LlmRequest) -> tuple[str, int]:
-    for index in range(len(request.contents) - 1, -1, -1):
-        content = request.contents[index]
-        if content.role != "user":
-            continue
-        text = "".join(part.text or "" for part in content.parts or [])
-        if text.strip():
-            return text.strip(), index
-    return "", -1
-
-
-def latest_tool_response(
-    request: LlmRequest, user_turn_index: int
-) -> dict[str, object] | None:
-    if user_turn_index < 0:
-        return None
-    for content in reversed(request.contents[user_turn_index + 1 :]):
-        for part in content.parts or []:
-            response = part.function_response
-            if response and response.name == TOOL_NAME:
-                return cast(dict[str, object], response.response or {})
-    return None
-
-
-def render_result(value: dict[str, object]) -> str:
-    answer = value.get("answer")
-    run_id = value.get("runId")
-    events = value.get("events")
-    if not isinstance(answer, str) or not isinstance(run_id, str):
-        return "真实 Agent 调试 Run 返回了无效结果。"
-    trace = json.dumps(events if isinstance(events, list) else [], ensure_ascii=False)
-    return f"{answer}\n\n---\n调试 Run：{run_id}\n事件摘要：{trace}"
-
-
-def text_response(text: str) -> LlmResponse:
-    return LlmResponse(
-        content=types.Content(role="model", parts=[types.Part(text=text)]),
-        partial=False,
-    )
-
-
-def build_root_agent(
-    operation: TextOperationDebugConfig | None,
-) -> LlmAgent:
-    return LlmAgent(
-        name="canonical_debug",
-        model=CanonicalDebugLlm(operation),
-        instruction=(
-            "每个业务问题都必须经 run_canonical_operation 交给 canonical Run；"
-            "不得自行回答、不得访问数据库或绕过平台授权。"
-        ),
-        tools=[run_canonical_operation] if operation else [],
-    )
-
-
-root_agent = build_root_agent(PROJECT_OPERATION)

package/template/apps/agent-server/adk_web_agents/safe_debug/__init__.py

@@ -1,3 +0,0 @@
-from .agent import root_agent
-
-__all__ = ["root_agent"]

package/template/apps/agent-server/adk_web_agents/safe_debug/agent.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator
-
-from google.adk.agents import LlmAgent
-from google.adk.models.base_llm import BaseLlm
-from google.adk.models.llm_request import LlmRequest
-from google.adk.models.llm_response import LlmResponse
-from google.genai import types
-
-
-class SafeDebugLlm(BaseLlm):
-    async def generate_content_async(
-        self,
-        llm_request: LlmRequest,
-        stream: bool = False,
-    ) -> AsyncGenerator[LlmResponse, None]:
-        del llm_request, stream
-        text = (
-            "这是 Windy 的 ADK 开发调试 Agent。"
-            "它不连接业务 Repository、Tool Host 或模型 Provider，"
-            "不能代表生产业务 Operation。"
-        )
-        yield LlmResponse(
-            content=types.Content(
-                role="model",
-                parts=[types.Part(text=text)],
-            ),
-            partial=False,
-        )
-
-
-root_agent = LlmAgent(
-    name="safe_debug",
-    model=SafeDebugLlm(model="windy-safe-debug"),
-    instruction=(
-        "仅说明开发调试边界；不访问业务数据，不调用 Tool，不连接模型 Provider。"
-    ),
-    tools=[],
-)

package/template/apps/agent-server/adk_web_agents/services.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from google.adk.cli.service_registry import get_service_registry
-
-from southwind_agent_server.adk_debug_sessions import (
-    WindyDebugSessionClientV1,
-    WindyDebugSessionServiceV1,
-)
-
-SESSION_SERVICE_URI = "windy-debug://v1"
-
-
-def create_windy_debug_session_service(
-    uri: str, **_kwargs: Any
-) -> WindyDebugSessionServiceV1:
-    if uri != SESSION_SERVICE_URI:
-        raise ValueError("Windy ADK debug session URI 版本不受支持")
-    return WindyDebugSessionServiceV1(WindyDebugSessionClientV1.from_environment())
-
-
-get_service_registry().register_session_service(
-    "windy-debug", create_windy_debug_session_service
-)

package/template/apps/agent-server/project/adk-web-debug.json

@@ -1,4 +0,0 @@
-{
-  "schemaVersion": 1,
-  "textOperation": null
-}