create-windy 0.6.12 → 0.6.14

package/template/apps/server/src/agent/run-routes.ts

@@ -4,6 +4,9 @@ import type { RouteApp } from "../system/routes.js";
 import type { AgentRunFacade } from "./run-facade.js";
 import { AgentRunFacadeError } from "./run-errors.js";
 import type { AgentRuntimePort } from "./run-contracts.js";
+import type { AgentRunSessionLinkPort } from "./session-run-link.js";
+import type { SessionRunResultMemoryPort } from "./session-result-memory.js";
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
 import {
   AgentToolHostError,
   attachExecutionGrant,
@@ -17,6 +20,7 @@ import {
   parseAttachRequest,
   parseCursor,
   parseOperationKey,
+  parseSessionId,
   parseStartRequest,
   parseToolRequest,
 } from "./run-route-input.js";
@@ -35,6 +39,8 @@ export function registerAgentRunRoutes(
   remote: AgentRuntimePort,
   toolHost: RestrictedAgentToolHost,
   internalToken: string,
+  sessionLinks?: AgentRunSessionLinkPort,
+  resultMemory?: SessionRunResultMemoryPort,
 ) {
   app.post("/agent/runs", async (raw) => {
     const context = raw as RouteContext;
@@ -52,6 +58,7 @@ export function registerAgentRunRoutes(
         request.artifacts,
         context.request.signal,
         request.screenshotIntakeToken,
+        request.sessionId,
       );
     } catch (error) {
       return facadeError(error);
@@ -79,8 +86,38 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const operationKey = parseOperationKey(context.query.operationKey);
-      await facade.authorizeRun(operationKey, runId, context.guardContext);
-      return await remote.result(runId, context.request.signal);
+      const sessionId = context.query.sessionId
+        ? parseSessionId(context.query.sessionId)
+        : undefined;
+      const authorized = await facade.authorizeRunMutation(
+        operationKey,
+        runId,
+        context.guardContext,
+        sessionId,
+      );
+      const response = await remote.result(runId, context.request.signal);
+      const boundSessionId = authorized.sessionId;
+      if (boundSessionId) {
+        const status = await remote.status(runId, context.request.signal);
+        if (
+          status.status === "completed" ||
+          status.status === "failed" ||
+          status.status === "cancelled"
+        ) {
+          if (status.status === "completed") {
+            await projectResult(resultMemory, boundSessionId, runId,
+              status.lastSequence, response, context);
+          }
+          await completeSessionRun(
+            sessionLinks,
+            boundSessionId,
+            runId,
+            status.status,
+            context.guardContext,
+          );
+        }
+      }
+      return response;
     } catch (error) {
       return facadeError(error);
     }
@@ -91,12 +128,39 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const operationKey = parseOperationKey(context.query.operationKey);
-      await facade.authorizeRun(operationKey, runId, context.guardContext);
+      const sessionId = context.query.sessionId
+        ? parseSessionId(context.query.sessionId)
+        : undefined;
+      const authorized = await facade.authorizeRunMutation(
+        operationKey,
+        runId,
+        context.guardContext,
+        sessionId,
+      );
       const reason =
         isRecord(context.body) && typeof context.body.reason === "string"
           ? context.body.reason.slice(0, 200)
           : undefined;
-      return await remote.cancel(runId, reason, context.request.signal);
+      const response = await remote.cancel(runId, reason, context.request.signal);
+      if (authorized.sessionId && response.ok) {
+        const status = await remote.status(runId, context.request.signal);
+        if (!["completed", "failed", "cancelled"].includes(status.status)) {
+          return response;
+        }
+        if (status.status === "completed") {
+          const result = await remote.result(runId, context.request.signal);
+          await projectResult(resultMemory, authorized.sessionId, runId,
+            status.lastSequence, result, context);
+        }
+        await completeSessionRun(
+          sessionLinks,
+          authorized.sessionId,
+          runId,
+          status.status as "completed" | "failed" | "cancelled",
+          context.guardContext,
+        );
+      }
+      return response;
     } catch (error) {
       return facadeError(error);
     }
@@ -107,13 +171,35 @@ export function registerAgentRunRoutes(
     try {
       const runId = required(context.params.runId);
       const request = parseAttachRequest(context.body);
-      return await facade.attach(
+      const authorized = await facade.authorizeRunMutation(
+        request.operationKey,
+        runId,
+        context.guardContext,
+        request.sessionId,
+      );
+      const attached = await facade.attach(
         request.operationKey,
         runId,
         request.cursor,
         context.guardContext,
         context.request.signal,
+        request.sessionId,
       );
+      if (authorized.sessionId && attached.terminalEvent) {
+        if (attached.status === "completed") {
+          const response = await remote.result(runId, context.request.signal);
+          await projectResult(resultMemory, authorized.sessionId, runId,
+            attached.terminalEvent.sequence, response, context);
+        }
+        await completeSessionRun(
+          sessionLinks,
+          authorized.sessionId,
+          runId,
+          attached.status as "completed" | "failed" | "cancelled",
+          context.guardContext,
+        );
+      }
+      return attached;
     } catch (error) {
       return facadeError(error);
     }
@@ -162,6 +248,48 @@ export function registerAgentRunRoutes(
   return app;
 }
 
+async function projectResult(
+  port: SessionRunResultMemoryPort | undefined,
+  sessionId: string,
+  runId: string,
+  terminalSequence: number,
+  response: Response,
+  context: RouteContext,
+) {
+  if (!port || !response.ok) {
+    throw new AgentRunFacadeError(
+      "RUNTIME_UNAVAILABLE",
+      "长期 Session Memory 暂不可用",
+      503,
+    );
+  }
+  await port.project({
+    sessionId,
+    runId,
+    terminalSequence,
+    result: await response.clone().json() as ModuleAiJsonValue,
+    context: context.guardContext,
+    signal: context.request.signal,
+  });
+}
+
+async function completeSessionRun(
+  port: AgentRunSessionLinkPort | undefined,
+  sessionId: string,
+  runId: string,
+  outcome: "completed" | "failed" | "cancelled",
+  context: RequestGuardContext,
+) {
+  if (!port) {
+    throw new AgentRunFacadeError(
+      "RUNTIME_UNAVAILABLE",
+      "长期 Session 暂不可用",
+      503,
+    );
+  }
+  await port.completeForRun({ sessionId, runId, outcome, context });
+}
+
 export function validInternalToken(
   request: Request,
   expected: string,

package/template/apps/server/src/agent/run-runtime-request.ts

@@ -0,0 +1,89 @@
+import {
+  resolveProviderEgress,
+  resolveToolNetworkPolicy,
+} from "@southwind-ai/modules";
+import type {
+  AiRuntimeDeploymentV1,
+  ModuleActor,
+  ModuleAiJsonValue,
+  ModuleAiOperationPlan,
+} from "@southwind-ai/server-sdk";
+import type {
+  AgentRuntimeArtifact,
+  AgentRuntimeOperation,
+} from "./run-contracts.js";
+import type { RegisteredOperation } from "./run-operation-registry.js";
+import type { resolveAgentRunExecutionPolicy } from "./agent-run-delegation-policy.js";
+import {
+  modelContextBinding,
+  type PendingSessionTurn,
+} from "./session-run-lifecycle.js";
+
+export function buildAgentRuntimeRequest(input: {
+  readonly operationKey: string;
+  readonly input: ModuleAiJsonValue;
+  readonly operation: RegisteredOperation;
+  readonly plan: ModuleAiOperationPlan;
+  readonly artifacts: readonly AgentRuntimeArtifact[];
+  readonly readinessPin?: AiRuntimeDeploymentV1;
+  readonly authorizationToken: string;
+  readonly release: AgentRuntimeOperation["release"];
+  readonly traceId: string;
+  readonly actor: ModuleActor;
+  readonly departmentId?: string;
+  readonly sessionTurn?: PendingSessionTurn;
+  readonly executionPolicy?: ReturnType<typeof resolveAgentRunExecutionPolicy>;
+}): AgentRuntimeOperation {
+  const operationLimits = input.operation.definition.limits;
+  const workflowBudget = input.executionPolicy?.workflowBudget;
+  return {
+    kind: "agent",
+    operationKey: input.operationKey,
+    input: input.input,
+    inputModalities: input.operation.definition.inputModalities ?? ["text"],
+    requiredCapabilities:
+      input.executionPolicy?.requiredCapabilities ??
+      input.operation.definition.requiredCapabilities,
+    artifacts: [...input.artifacts],
+    instructions: input.plan.instructions,
+    userPrompt: input.plan.userPrompt,
+    outputSchemaKey: input.operation.definition.outputSchemaKey,
+    ...(input.plan.outputSchema === undefined
+      ? {}
+      : { outputSchema: input.plan.outputSchema }),
+    allowedTools: input.executionPolicy?.allowedTools ?? input.operation.tools,
+    limits: {
+      ...operationLimits,
+      ...(workflowBudget ?? {}),
+      maxDurationSeconds: workflowBudget
+        ? Math.min(
+            operationLimits.maxDurationSeconds,
+            workflowBudget.maxDurationSeconds,
+          )
+        : operationLimits.maxDurationSeconds,
+    },
+    providerEgress: resolveProviderEgress(input.operation.definition),
+    providerDataPolicy: input.operation.definition.providerDataPolicy ?? {
+      inputFields: [],
+      envelopeFields: [],
+    },
+    toolNetworkPolicy: resolveToolNetworkPolicy(input.operation.definition),
+    ...(input.readinessPin ? { readinessPin: input.readinessPin } : {}),
+    ...(input.executionPolicy?.modelPin
+      ? { modelPin: input.executionPolicy.modelPin }
+      : {}),
+    executionGrant: input.authorizationToken,
+    release: input.release,
+    traceId: input.traceId,
+    reporting: {
+      actorId: input.actor.id,
+      actorType: input.actor.type,
+      ...(input.departmentId ? { departmentId: input.departmentId } : {}),
+    },
+    ...(input.sessionTurn
+      ? {
+          longSession: modelContextBinding(input.sessionTurn),
+        }
+      : {}),
+  };
+}

package/template/apps/server/src/agent/run-session-authorization.ts

@@ -0,0 +1,95 @@
+import type { ModuleManifest } from "@southwind-ai/modules";
+import { evaluateAccessGuards } from "../access-guards.js";
+import type { RequestGuardContext } from "../guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import { AgentRunFacadeError, inaccessibleRun } from "./run-errors.js";
+import type { RegisteredOperation } from "./run-operation-registry.js";
+import type { AgentRunSessionLinkPort } from "./session-run-link.js";
+
+const SESSION_FEATURE_KEY = "system.agent-session";
+type GuardRuntime = Pick<
+  ReturnType<typeof createServerRuntime>,
+  "recordDecisions" | "resolveFeature"
+>;
+
+/**
+ * Binding a Run to a long-lived Session is an additional governed write. The
+ * operation's own Agent permission never implies this capability.
+ */
+export class AgentRunSessionBindingAuthorizer {
+  readonly #feature: ModuleManifest["features"][number] | undefined;
+
+  constructor(
+    modules: readonly ModuleManifest[],
+    private readonly runtime: GuardRuntime,
+  ) {
+    this.#feature = modules
+      .flatMap(({ features }) => features)
+      .find(({ key }) => key === SESSION_FEATURE_KEY);
+  }
+
+  async requireManage(context: RequestGuardContext): Promise<void> {
+    if (!this.#feature) {
+      throw new AgentRunFacadeError(
+        "RUNTIME_UNAVAILABLE",
+        "长期 Session 治理能力暂不可用",
+        503,
+      );
+    }
+    const access = await evaluateAccessGuards(this.runtime, context, {
+      permission: { permissionKey: `${this.#feature.key}.manage` },
+      feature: this.#feature,
+    });
+    if (!access.decision.allowed) {
+      throw new AgentRunFacadeError(
+        "FORBIDDEN",
+        "无权写入长期 Session",
+        403,
+      );
+    }
+  }
+}
+
+export async function authorizeAgentRunStart(input: {
+  readonly runtime: GuardRuntime;
+  readonly operation: RegisteredOperation;
+  readonly context: RequestGuardContext;
+  readonly sessionBinding?: AgentRunSessionBindingAuthorizer;
+}): Promise<void> {
+  const decision = await evaluateAccessGuards(input.runtime, input.context, {
+    permission: {
+      permissionKey: input.operation.definition.permissionKey,
+    },
+    feature: input.operation.feature,
+  });
+  if (!decision.decision.allowed) {
+    throw new AgentRunFacadeError(
+      "FORBIDDEN",
+      "无权执行 Agent Operation",
+      403,
+    );
+  }
+  await input.sessionBinding?.requireManage(input.context);
+}
+
+export async function authorizeAgentRunSessionWrite(input: {
+  readonly authorizer: AgentRunSessionBindingAuthorizer;
+  readonly links?: AgentRunSessionLinkPort;
+  readonly sessionId: string;
+  readonly runId: string;
+  readonly context: RequestGuardContext;
+}): Promise<void> {
+  await input.authorizer.requireManage(input.context);
+  if (!input.links) {
+    throw new AgentRunFacadeError(
+      "RUNTIME_UNAVAILABLE",
+      "长期 Session 暂不可用",
+      503,
+    );
+  }
+  try {
+    await input.links.requireRunBinding(input);
+  } catch {
+    throw inaccessibleRun();
+  }
+}

package/template/apps/server/src/agent/run-start-preparation.ts

@@ -0,0 +1,71 @@
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import type { RequestGuardContext } from "../guards.js";
+import { toModuleActor } from "../module-host.js";
+import { normalizeMemoryScopeCaseId } from "./memory-scope-binding.js";
+import {
+  governProviderInput,
+  projectProviderInput,
+  ProviderInputGovernanceError,
+} from "./provider-input-governance.js";
+import { assertInputSize } from "./run-definition-support.js";
+import { AgentRunFacadeError } from "./run-errors.js";
+import type { RegisteredOperation } from "./run-operation-registry.js";
+import { validateRegisteredOutputSchema } from "./run-output-schema.js";
+
+export async function prepareAgentRunStart(
+  operation: RegisteredOperation,
+  input: ModuleAiJsonValue,
+  context: RequestGuardContext,
+) {
+  assertInputSize(input, operation.definition.limits.maxInputBytes);
+  const providerPolicy = operation.definition.providerDataPolicy;
+  if (
+    operation.definition.providerEgress?.mode === "configured-endpoint" &&
+    !providerPolicy
+  ) {
+    throw new AgentRunFacadeError(
+      "FORBIDDEN",
+      "Agent Operation 缺少 Provider 字段治理策略",
+      403,
+    );
+  }
+  let governedInput = input;
+  let committedInput = input;
+  try {
+    committedInput = providerPolicy
+      ? projectProviderInput(input, providerPolicy)
+      : input;
+    governedInput = providerPolicy
+      ? governProviderInput(input, providerPolicy)
+      : input;
+  } catch (error) {
+    if (error instanceof ProviderInputGovernanceError) {
+      throw new AgentRunFacadeError(
+        error.code,
+        error.message,
+        error.code === "FORBIDDEN" ? 403 : 400,
+      );
+    }
+    throw error;
+  }
+  const moduleActor = toModuleActor(context.actor);
+  const plan = await operation.registration!.prepare!(governedInput, {
+    actor: moduleActor,
+    requestId: context.requestId,
+  });
+  if (!plan.instructions.trim() || !plan.userPrompt.trim()) {
+    throw new AgentRunFacadeError(
+      "INVALID_INPUT",
+      "Agent Operation 执行计划无效",
+      400,
+    );
+  }
+  validateRegisteredOutputSchema(plan.outputSchema, operation);
+  return {
+    committedInput,
+    governedInput,
+    moduleActor,
+    plan,
+    currentCaseId: normalizeMemoryScopeCaseId(plan.memoryScope),
+  };
+}

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

@@ -0,0 +1,42 @@
+import type { PlatformConfig } from "@southwind-ai/config";
+import type { DurableHandlerRegistry } from "@southwind-ai/jobs";
+import type { ModuleManifest } from "@southwind-ai/modules";
+import type { ModuleClientAgentHostAuthAdapter } from "@southwind-ai/server-sdk";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { InitializedModuleHosts } from "../module-host.js";
+import type { createServerRuntime } from "../runtime.js";
+import type { RouteApp } from "../system/routes.js";
+import type { createStorageRuntime } from "../storage/runtime.js";
+import type { SystemRepositories } from "../system/seed.js";
+import type { WorkflowService } from "../workflow/service.js";
+import type { DurableArtifactService } from "../jobs/artifact-service.js";
+import type { DurableJobService } from "../jobs/service.js";
+import type { DurableJobWorker } from "../jobs/worker.js";
+import type { DeferredAgentBackgroundOperationPortFactory } from "./background-operation-port.js";
+import type { ModuleAuthoritativeSourceAdapterRegistration } from "./context-memory/authoritative-source-registry.js";
+import type { ModuleMemoryObjectAdapterRegistration } from "./context-memory/memory-object-registry.js";
+import type { ScreenshotPageRegistryV2 } from "./persistent-screenshot-intake-producer.js";
+import type { AgentWorkflowWorkspacePolicyDefinition } from "../agent-workflow/workspace-policy.js";
+
+export interface AgentPlatformRuntimeInput {
+  app: RouteApp;
+  platformConfig: PlatformConfig;
+  modules: readonly ModuleManifest[];
+  hosts: InitializedModuleHosts;
+  runtime: ReturnType<typeof createServerRuntime>;
+  systemRepositories: SystemRepositories;
+  storage: ReturnType<typeof createStorageRuntime>;
+  workflow: WorkflowService;
+  jobs: DurableJobService;
+  jobWorker: DurableJobWorker;
+  jobRegistry: DurableHandlerRegistry;
+  jobArtifacts: DurableArtifactService;
+  onWorkflowContinuationError(error: unknown): void;
+  db?: NodePgDatabase;
+  backgroundAi: DeferredAgentBackgroundOperationPortFactory;
+  screenshotPageRegistry?: ScreenshotPageRegistryV2;
+  clientAgentHostAuth?: ModuleClientAgentHostAuthAdapter;
+  authoritativeSessionSources?: readonly ModuleAuthoritativeSourceAdapterRegistration[];
+  sessionMemoryObjects?: readonly ModuleMemoryObjectAdapterRegistration[];
+  agentWorkflowWorkspacePolicies?: readonly AgentWorkflowWorkspacePolicyDefinition[];
+}

package/template/apps/server/src/agent/runtime-bootstrap-report.test.ts

@@ -6,7 +6,10 @@ import { createServerRuntime } from "../runtime.js";
 import { createSystemRepositories } from "../system/seed.js";
 import { FakeRouteApp } from "../system/route-test-app.js";
 import { registerAiRuntimeReporting } from "./runtime-reporting-bootstrap.js";
-import { registerUnavailableAiRoutes } from "./unavailable-routes.js";
+import {
+  registerUnavailableAiRoutes,
+  registerUnavailableClientAgentSessionRoutes,
+} from "./unavailable-routes.js";
 
 const originalFetch = globalThis.fetch;
 
@@ -99,6 +102,55 @@ describe("AI Runtime 报表生产组合", () => {
       });
     }
   });
+
+  test("AI disabled 时长期 Session Manifest 路由全部 fail closed", async () => {
+    const app = new FakeRouteApp();
+    registerUnavailableAiRoutes(app);
+
+    for (const [method, path] of [
+      ["GET", "/agent/harness/sessions"],
+      ["GET", "/agent/harness/sessions/:sessionId"],
+      ["GET", "/agent/harness/sessions/:sessionId/context-versions"],
+      ["GET", "/agent/harness/sessions/:sessionId/memories"],
+      ["POST", "/agent/harness/sessions"],
+      ["POST", "/agent/harness/sessions/:sessionId/checkpoints"],
+      ["POST", "/agent/harness/sessions/:sessionId/replay"],
+      ["POST", "/agent/harness/sessions/:sessionId/forks"],
+      ["POST", "/agent/harness/sessions/:sessionId/archive"],
+      ["POST", "/internal/agent/context-versions"],
+      ["DELETE", "/agent/harness/sessions/:sessionId/memories/:memoryId"],
+    ] as const) {
+      const response = (await app.invoke(method, path, {})) as Response;
+      expect(response.status).toBe(503);
+      await expect(response.json()).resolves.toEqual({
+        code: "RUNTIME_UNAVAILABLE",
+        message: "AI Runtime 未启用",
+      });
+    }
+  });
+
+  test("AI enabled 但 Host Auth 未装配时客户端会话路由明确返回 503", async () => {
+    const app = new FakeRouteApp();
+    registerUnavailableClientAgentSessionRoutes(app);
+
+    for (const [method, path] of [
+      ["GET", "/agent/client-sessions/capabilities"],
+      ["POST", "/agent/client-sessions"],
+      ["POST", "/agent/client-sessions/revoke"],
+      ["GET", "/agent/client-sessions/:sessionId"],
+      ["GET", "/agent/client-sessions/:sessionId/result"],
+      ["POST", "/agent/client-sessions/:sessionId/v1/chat/completions"],
+      ["POST", "/agent/client-sessions/:sessionId/finalize"],
+      ["POST", "/agent/client-sessions/:sessionId/cancel"],
+    ] as const) {
+      const response = (await app.invoke(method, path, {})) as Response;
+      expect(response.status).toBe(503);
+      await expect(response.json()).resolves.toEqual({
+        code: "RUNTIME_UNAVAILABLE",
+        message: "Client Agent Session 未装配",
+      });
+    }
+  });
 });
 
 function emptySummary() {