create-windy 0.6.12 → 0.6.14

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

@@ -1,10 +1,3 @@
-import type { PlatformConfig } from "@southwind-ai/config";
-import type { ModuleManifest } from "@southwind-ai/modules";
-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 { resolveCurrentSystemActor } from "../system/actor.js";
 import { AiArtifactCodec } from "../ai-artifact/codec.js";
 import { registerAiArtifactRoutes } from "../ai-artifact/routes.js";
@@ -39,82 +32,40 @@ import {
 import { registerSpeechRunRoutes } from "../speech/routes.js";
 import { ExecutionGrantStore } from "./execution-grants.js";
 import { RemoteAgentRuntime } from "./remote-runtime.js";
-import { GovernedToolRegistry } from "./tool-registry.js";
 import { AgentRunFacade } from "./run-facade.js";
 import { registerAgentRunRoutes } from "./run-routes.js";
 import { RestrictedAgentToolHost } from "./tool-host.js";
-import { createSystemToolHandlers, registerAgentRoutes } from "./routes.js";
-import { createModuleToolHandlerMap } from "../module-host.js";
-import { PlatformMcpAdapter } from "../mcp/adapter.js";
-import { registerMcpRoutes } from "../mcp/routes.js";
-import type { WorkflowService } from "../workflow/service.js";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { DrizzleAgentRunBindingRepository } from "./drizzle-run-binding-repository.js";
 import { AgentRunAuthorizationStore } from "./run-authorization.js";
 import { InMemoryAgentRunBindingRepository } from "./run-binding-repository.js";
 import { AgentBackgroundOperationExecutor } from "./background-operation.js";
-import type { DeferredAgentBackgroundOperationPortFactory } from "./background-operation-port.js";
-import { UnixSandboxToolClient } from "./sandbox-client.js";
-import { createModuleAiOperationPort } from "../module-host/ai-operation-port.js";
-import {
-  createManifestAuthorizedRouteApp,
-  createStaticRouteAuthorizer,
-} from "../module-host/static-route-authorization.js";
+import { createModuleAiPorts } from "./module-ai-port-factory.js";
+import { createManifestAuthorizedRouteApp } from "../module-host/static-route-authorization.js";
 import { registerUnavailableAiRoutes } from "./unavailable-routes.js";
-import { DebugSessionFacadeV1 } from "./debug-session-facade.js";
-import { DebugSessionIdCodecV1 } from "./debug-session-id.js";
-import { registerDebugSessionRoutesV1 } from "./debug-session-routes.js";
+import { createClientAgentSessionRuntime } from "./client-session/bootstrap.js";
+import { registerAgentSessions } from "./agent-session-bootstrap.js";
 import { createAiRuntimeReadinessSources } from "./runtime-readiness-sources.js";
 import { registerAiRuntimeReporting } from "./runtime-reporting-bootstrap.js";
 import { registerScreenshotIntakeRoutes } from "./screenshot-intake-routes.js";
 import { createScreenshotIntakeRuntimeV2 } from "./screenshot-intake-bootstrap.js";
-import type { ScreenshotPageRegistryV2 } from "./persistent-screenshot-intake-producer.js";
 import { requiredEnvironment } from "./required-environment.js";
-export { registerAiRuntimeReporting } from "./runtime-reporting-bootstrap.js";
-
-export function registerAgentPlatformRuntime(input: {
-  app: RouteApp;
-  platformConfig: PlatformConfig;
-  modules: readonly ModuleManifest[];
-  hosts: InitializedModuleHosts;
-  runtime: ReturnType<typeof createServerRuntime>;
-  systemRepositories: SystemRepositories;
-  storage: ReturnType<typeof createStorageRuntime>;
-  workflow: WorkflowService;
-  db?: NodePgDatabase;
-  backgroundAi: DeferredAgentBackgroundOperationPortFactory;
-  screenshotPageRegistry?: ScreenshotPageRegistryV2;
-}) {
-  const features = input.modules.flatMap(({ features }) => features);
+import { composeAgentLongSessionRuntime } from "./session-runtime-composition.js";
+import type { AgentPlatformRuntimeInput } from "./runtime-bootstrap-input.js";
+import { createModuleAgentSessionMemoryPort } from "../module-host/agent-session-memory-port.js";
+import { createModuleAuthoritativeSourceInvalidationPort } from "../module-host/agent-source-invalidation-port.js";
+import { composeAgentToolRuntime } from "./runtime-tool-composition.js";
+import { registerProductionAgentWorkflowRuntime } from "./workflow-runtime-bootstrap.js";
+export function registerAgentPlatformRuntime(input: AgentPlatformRuntimeInput) {
   const resolveAgentActor = async (actorId: string) =>
-    (await input.runtime.resolveEphemeralActor(actorId)) ??
-    (await resolveCurrentSystemActor(input.systemRepositories, actorId));
-  const toolHandlers = new Map([
-    ...createSystemToolHandlers(input.systemRepositories, input.runtime),
-    ...createModuleToolHandlerMap(input.hosts, {
-      runtime: input.runtime,
-      features,
-      storage: input.storage,
-      sandbox: process.env.TOOL_SANDBOX_SOCKET?.trim()
-        ? new UnixSandboxToolClient(process.env.TOOL_SANDBOX_SOCKET)
-        : undefined,
-    }),
-  ]);
-  const toolRegistry = new GovernedToolRegistry(
-    input.modules,
-    toolHandlers,
-    input.runtime,
-  );
-  const routeAuthorizer = createStaticRouteAuthorizer(
-    input.runtime,
-    input.modules,
-  );
-  registerAgentRoutes(input.app, toolRegistry, routeAuthorizer);
-  registerMcpRoutes(
+    resolveCurrentSystemActor(input.systemRepositories, actorId);
+  const { features, toolHandlers, toolRegistry, routeAuthorizer } =
+    composeAgentToolRuntime(input);
+  const aiRouteApp = createManifestAuthorizedRouteApp(
     input.app,
-    new PlatformMcpAdapter(toolRegistry, input.runtime, features),
+    routeAuthorizer,
   );
   if (!input.platformConfig.enableAI) {
+    registerProductionAgentWorkflowRuntime(input, aiRouteApp, toolRegistry);
     registerUnavailableAiRoutes(
       createManifestAuthorizedRouteApp(input.app, routeAuthorizer),
     );
@@ -123,31 +74,18 @@ export function registerAgentPlatformRuntime(input: {
       aiArtifacts: undefined,
       aiOperations: undefined,
       aiReadiness: undefined,
+      clientAgentSessions: undefined,
+      sessionMemory: undefined,
+      sourceInvalidation: undefined,
+      invalidateAuthorization: undefined,
       disposeAgentRuntime: undefined,
     };
   }
-  const aiRouteApp = createManifestAuthorizedRouteApp(
-    input.app,
-    routeAuthorizer,
-  );
-  const debugToken =
-    process.env.NODE_ENV === "development" &&
-    process.env.WINDY_ADK_DEBUG_OPERATION_KEY?.trim()
-      ? process.env.WINDY_ADK_DEBUG_TOKEN?.trim()
-      : undefined;
-  if (debugToken) {
-    registerDebugSessionRoutesV1(
-      input.app,
-      new DebugSessionFacadeV1(
-        input.hosts,
-        input.runtime,
-        new DebugSessionIdCodecV1(debugToken),
-      ),
-    );
-  }
+  const sessionSecret = requiredEnvironment("AI_ARTIFACT_ENCRYPTION_SECRET");
   const internalToken = requiredEnvironment("AGENT_SERVER_INTERNAL_TOKEN");
+  registerAgentSessions({ ...input, secret: internalToken });
   const aiArtifacts = new AiArtifactRuntime(
-    new AiArtifactCodec(requiredEnvironment("AI_ARTIFACT_ENCRYPTION_SECRET")),
+    new AiArtifactCodec(sessionSecret),
     input.hosts,
     input.runtime,
     features,
@@ -162,6 +100,19 @@ export function registerAgentPlatformRuntime(input: {
     internalToken,
     toolHostUrl: process.env.AGENT_TOOL_HOST_URL || "http://server:9747",
   });
+  const clientAgentSessionRuntime = createClientAgentSessionRuntime({
+    app: input.app,
+    modules: input.modules,
+    hosts: input.hosts,
+    runtime: input.runtime,
+    db: input.db,
+    agentServerUrl,
+    internalToken,
+    hostAuth: input.clientAgentHostAuth,
+    routeAuthorizer,
+    resolveActor: resolveAgentActor,
+  });
+  const clientAgentSessions = clientAgentSessionRuntime?.service;
   const screenshotIntake = createScreenshotIntakeRuntimeV2({
     modules: input.modules,
     runtime: input.runtime,
@@ -185,6 +136,19 @@ export function registerAgentPlatformRuntime(input: {
       : new InMemoryAgentRunBindingRepository(),
     internalToken,
   );
+  const longSessions = composeAgentLongSessionRuntime({
+    app: aiRouteApp,
+    db: input.db,
+    secret: sessionSecret,
+    internalToken,
+    modules: input.modules,
+    runtime: input.runtime,
+    remote,
+    authorizations: runAuthorizations,
+    resolveActor: resolveAgentActor,
+    authoritativeSources: input.authoritativeSessionSources,
+    memoryObjects: input.sessionMemoryObjects,
+  });
   const documentRemote = process.env.DOCUMENT_SERVER_URL?.trim()
     ? new RemoteDocumentRuntime({
         baseUrl: process.env.DOCUMENT_SERVER_URL,
@@ -279,6 +243,22 @@ export function registerAgentPlatformRuntime(input: {
     runAuthorizations,
     aiArtifacts,
     screenshotIntake,
+    longSessions?.runLink,
+  );
+  const agentWorkflowRuntime = registerProductionAgentWorkflowRuntime(
+    input,
+    aiRouteApp,
+    toolRegistry,
+    {
+      agentFacade,
+      agentRemote: remote,
+      agentAuthorizations: runAuthorizations,
+      agentServerUrl,
+      internalToken,
+      artifactSources: longSessions?.authoritativeSources,
+      sessionLog: longSessions?.sessionLog,
+      resolveActor: resolveAgentActor,
+    },
   );
   registerScreenshotIntakeRoutes(aiRouteApp, screenshotIntake);
   registerAgentRunRoutes(
@@ -293,8 +273,11 @@ export function registerAgentPlatformRuntime(input: {
       runAuthorizations,
       input.workflow,
       resolveAgentActor,
+      agentWorkflowRuntime?.delegatedToolAuthorization,
     ),
     internalToken,
+    longSessions?.runLink,
+    longSessions?.resultMemory,
   );
   input.backgroundAi.bind(
     new AgentBackgroundOperationExecutor(
@@ -304,12 +287,12 @@ export function registerAgentPlatformRuntime(input: {
       remote,
     ),
   );
-  const aiOperations = (
-    moduleName: string,
-    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
-    signal: AbortSignal,
-  ) =>
-    createModuleAiOperationPort(moduleName, guardContext, signal, {
+  const moduleAi = createModuleAiPorts({
+    modules: input.modules,
+    runtime: input.runtime,
+    sources: readinessSources,
+    trustStore: readinessTrustStore,
+    operations: {
       agentFacade,
       agentRemote: remote,
       documentFacade: documentFacadeWithOutput,
@@ -318,28 +301,48 @@ export function registerAgentPlatformRuntime(input: {
       speechRemote,
       embeddingFacade,
       modules: input.modules,
-    });
-  const aiReadinessForModule = (
-    moduleName: string,
-    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
-    signal: AbortSignal,
-  ) =>
-    createModuleAiOperationReadinessPort({
-      moduleName,
-      guardContext,
-      signal,
-      modules: input.modules,
-      sources: readinessSources,
-      trustStore: readinessTrustStore,
-      runtime: input.runtime,
-    });
+    },
+  });
   return {
     toolHandlers,
     aiArtifacts,
-    aiOperations,
-    aiReadiness: aiReadinessForModule,
-    disposeAgentRuntime: screenshotIntake
-      ? () => screenshotIntake.dispose()
+    aiOperations: moduleAi.operations,
+    aiReadiness: moduleAi.readiness,
+    clientAgentSessions,
+    sessionMemory: longSessions
+      ? (
+          moduleName: string,
+          context: Parameters<typeof createModuleAgentSessionMemoryPort>[1],
+          signal: AbortSignal,
+        ) =>
+          createModuleAgentSessionMemoryPort(
+            moduleName,
+            context,
+            signal,
+            longSessions.memoryProjector,
+          )
+      : undefined,
+    sourceInvalidation: longSessions
+      ? (
+          moduleName: string,
+          context: Parameters<
+            typeof createModuleAuthoritativeSourceInvalidationPort
+          >[1],
+          signal: AbortSignal,
+        ) =>
+          createModuleAuthoritativeSourceInvalidationPort(
+            moduleName,
+            context,
+            signal,
+            longSessions.authoritativeSources,
+            longSessions.invalidationOutbox,
+          )
       : undefined,
+    invalidateAuthorization: longSessions?.invalidateAuthorization,
+    disposeAgentRuntime() {
+      screenshotIntake?.dispose();
+      clientAgentSessionRuntime.dispose?.();
+      longSessions?.dispose();
+    },
   };
 }

package/template/apps/server/src/agent/runtime-tool-composition.ts

@@ -0,0 +1,38 @@
+import { createModuleToolHandlerMap } from "../module-host.js";
+import { PlatformMcpAdapter } from "../mcp/adapter.js";
+import { registerMcpRoutes } from "../mcp/routes.js";
+import { createStaticRouteAuthorizer } from "../module-host/static-route-authorization.js";
+import { UnixSandboxToolClient } from "./sandbox-client.js";
+import { GovernedToolRegistry } from "./tool-registry.js";
+import { createSystemToolHandlers, registerAgentRoutes } from "./routes.js";
+import type { AgentPlatformRuntimeInput } from "./runtime-bootstrap-input.js";
+
+export function composeAgentToolRuntime(input: AgentPlatformRuntimeInput) {
+  const features = input.modules.flatMap(({ features }) => features);
+  const toolHandlers = new Map([
+    ...createSystemToolHandlers(input.systemRepositories, input.runtime),
+    ...createModuleToolHandlerMap(input.hosts, {
+      runtime: input.runtime,
+      features,
+      storage: input.storage,
+      sandbox: process.env.TOOL_SANDBOX_SOCKET?.trim()
+        ? new UnixSandboxToolClient(process.env.TOOL_SANDBOX_SOCKET)
+        : undefined,
+    }),
+  ]);
+  const toolRegistry = new GovernedToolRegistry(
+    input.modules,
+    toolHandlers,
+    input.runtime,
+  );
+  const routeAuthorizer = createStaticRouteAuthorizer(
+    input.runtime,
+    input.modules,
+  );
+  registerAgentRoutes(input.app, toolRegistry, routeAuthorizer);
+  registerMcpRoutes(
+    input.app,
+    new PlatformMcpAdapter(toolRegistry, input.runtime, features),
+  );
+  return { features, toolHandlers, toolRegistry, routeAuthorizer };
+}

package/template/apps/server/src/agent/session-context-source-support.ts

@@ -0,0 +1,38 @@
+import type { SessionId } from "./session-log/domain.js";
+import type { SessionEventEnvelope } from "./session-log/events.js";
+import type { DrizzleSessionEventRepository } from "./session-persistence/drizzle-session-repository.js";
+
+export async function linkedRun(
+  repository: DrizzleSessionEventRepository,
+  sessionId: SessionId,
+  runId: string,
+) {
+  const session = await repository.get(sessionId);
+  if (!session) return false;
+  const events = await repository.read({
+    sessionId,
+    afterSequence: 0,
+    throughSequence: session.headSequence,
+    limit: Math.max(1, session.headSequence),
+  });
+  return events.some(
+    ({ data }) => data.type === "run.linked" && data.runId === runId,
+  );
+}
+
+export function sessionTurnContextContent(event: SessionEventEnvelope) {
+  if (event.data.type !== "turn.started") {
+    throw new Error("Context 来源不是 Turn 起始事实");
+  }
+  return JSON.stringify({
+    type: event.data.type,
+    cause: event.data.cause,
+    currentCaseId: event.data.currentCaseId,
+    input: event.data.input,
+    occurredAt: event.occurredAt,
+  });
+}
+
+export function deniedSourceAccess() {
+  return { outcome: "denied", reason: "object-forbidden" } as const;
+}