create-windy 0.9.1 → 0.10.1

package/template/apps/server/src/media-runtime/module-ai-port-factory.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { systemModuleManifest } from "@southwind-ai/modules";
+import {
+  operationKey,
+  readinessManifest,
+  readySnapshot,
+} from "../ai-runtime-readiness/operation-port.test-support.js";
+import { AiRuntimeReadinessTrustStoreV1 } from "../ai-runtime-readiness/trust-store.js";
+import { createServerRuntime } from "../runtime.js";
+import { createModuleAiPorts } from "./module-ai-port-factory.js";
+
+test("已授权的业务 Operation 在 Document Feature 关闭时不探测远端", async () => {
+  const modules = [
+    readinessManifest(),
+    systemModuleManifest("system.media-runtime"),
+  ];
+  const featureCatalog = modules.flatMap((module) => module.features);
+  const runtime = createServerRuntime(
+    {},
+    {
+      featureCatalog,
+      disabledFeatureKeys: new Set(["system.document"]),
+      licenseEnforced: false,
+    },
+  );
+  const context = await runtime.createGuardContextForActor(
+    new Request("http://localhost/evidence"),
+    {
+      id: "ocr-operator",
+      type: "user",
+      name: "OCR operator",
+      roleCodes: [],
+      permissionKeys: ["evidence.document.ocr.execute"],
+    },
+  );
+  let probes = 0;
+  const ports = createModuleAiPorts({
+    modules,
+    runtime,
+    sources: [
+      {
+        kind: "document",
+        async health() {
+          probes += 1;
+          return Response.json(readySnapshot());
+        },
+      },
+    ],
+    operations: { modules },
+    trustStore: new AiRuntimeReadinessTrustStoreV1(),
+  });
+  const signal = AbortSignal.timeout(1_000);
+  await expect(
+    ports.readiness("evidence", context, signal).inspect({ operationKey }),
+  ).resolves.toMatchObject({
+    runtimeKind: "document",
+    status: "unavailable",
+    unavailableReasons: [{ code: "RUNTIME_NOT_CONFIGURED" }],
+  });
+  expect(probes).toBe(0);
+  await expect(
+    ports.operations("evidence", context, signal).startDocument({
+      operationKey,
+      sources: [],
+      options: {},
+      idempotencyKey: "regression",
+    }),
+  ).rejects.toMatchObject({ code: "AI_OPERATION_UNAVAILABLE" });
+});

package/template/apps/server/src/media-runtime/module-ai-port-factory.ts

@@ -0,0 +1,72 @@
+import type { AiRuntimeKind } from "@southwind-ai/shared";
+import { ModuleAiOperationError } from "@southwind-ai/server-sdk";
+import { evaluateFeatureGuard } from "../guards.js";
+import type { ModuleManifest } from "@southwind-ai/modules";
+import { createModuleAiOperationReadinessPort } from "../ai-runtime-readiness/operation-port.js";
+import type { AiRuntimeReadinessTrustStoreV1 } from "../ai-runtime-readiness/trust-store.js";
+import { createModuleAiOperationPort } from "../module-host/ai-operation-port.js";
+import type { createServerRuntime } from "../runtime.js";
+
+type OperationRuntime = Parameters<typeof createModuleAiOperationPort>[3];
+type ReadinessInput = Parameters<
+  typeof createModuleAiOperationReadinessPort
+>[0];
+
+export function createModuleAiPorts(input: {
+  readonly modules: readonly ModuleManifest[];
+  readonly runtime: ReturnType<typeof createServerRuntime>;
+  readonly sources: ReadinessInput["sources"];
+  readonly trustStore: AiRuntimeReadinessTrustStoreV1;
+  readonly operations: OperationRuntime;
+}) {
+  const features = new Map(
+    input.modules.flatMap((module) =>
+      module.features.map((feature) => [String(feature.key), feature] as const),
+    ),
+  );
+  const runtimeAllowed = async (
+    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
+    kind: AiRuntimeKind,
+  ) => {
+    const feature = features.get(`system.${kind}`);
+    if (!feature) return false;
+    const decision = evaluateFeatureGuard(
+      guardContext,
+      await input.runtime.resolveFeature(guardContext, feature),
+    );
+    if (!decision.allowed) input.runtime.recordDecisions([decision]);
+    return decision.allowed;
+  };
+  const operations = (
+    moduleName: string,
+    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
+    signal: AbortSignal,
+  ) =>
+    createModuleAiOperationPort(moduleName, guardContext, signal, {
+      ...input.operations,
+      async requireFeature(kind) {
+        if (!(await runtimeAllowed(guardContext, kind))) {
+          throw new ModuleAiOperationError(
+            "AI_OPERATION_UNAVAILABLE",
+            `${kind} Feature 未启用`,
+          );
+        }
+      },
+    });
+  const readiness = (
+    moduleName: string,
+    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
+    signal: AbortSignal,
+  ) =>
+    createModuleAiOperationReadinessPort({
+      moduleName,
+      guardContext,
+      signal,
+      modules: input.modules,
+      sources: input.sources,
+      trustStore: input.trustStore,
+      runtimeAllowed: (kind) => runtimeAllowed(guardContext, kind),
+      runtime: input.runtime,
+    });
+  return { operations, readiness };
+}

package/template/apps/server/src/{agent → media-runtime}/runtime-readiness-sources.ts

@@ -1,3 +1,4 @@
+import type { AiRuntimeSwitches } from "@southwind-ai/shared";
 import type { AiRuntimeReadinessSourceV1 } from "../ai-runtime-readiness/operation-port.js";
 
 interface HealthPort {
@@ -5,16 +6,22 @@ interface HealthPort {
 }
 
 export function createAiRuntimeReadinessSources(input: {
-  agent: HealthPort;
+  agent?: HealthPort;
   document: HealthPort;
   speech: HealthPort;
   embedding: HealthPort;
+  switches?: AiRuntimeSwitches;
 }): readonly AiRuntimeReadinessSourceV1[] {
-  return [
-    {
-      kind: "agent",
-      health: (signal) => input.agent.health(signal),
-    },
+  const agent = input.agent;
+  const sources: AiRuntimeReadinessSourceV1[] = [
+    ...(agent
+      ? [
+          {
+            kind: "agent" as const,
+            health: (signal?: AbortSignal) => agent.health(signal),
+          },
+        ]
+      : []),
     {
       kind: "document",
       health: (signal) => input.document.health(signal),
@@ -28,4 +35,5 @@ export function createAiRuntimeReadinessSources(input: {
       health: (signal) => input.embedding.health(signal),
     },
   ];
+  return sources.filter(({ kind }) => input.switches?.[kind] !== false);
 }

package/template/apps/server/src/media-runtime/shared-composition.ts

@@ -0,0 +1,104 @@
+import { AiArtifactCodec } from "../ai-artifact/codec.js";
+import { registerAiArtifactRoutes } from "../ai-artifact/routes.js";
+import { AiArtifactRuntime } from "../ai-artifact/runtime.js";
+import { createModuleAiOperationReadinessPort } from "../ai-runtime-readiness/operation-port.js";
+import { AiRuntimeReadinessTrustStoreV1 } from "../ai-runtime-readiness/trust-store.js";
+import { connectMediaRuntimes, registerMediaRuntimes } from "./composition.js";
+import { ExecutionGrantStore } from "../ai-runtime-security/execution-grants.js";
+import type {
+  AiRuntimeSwitches,
+  FeatureFlagDefinition,
+} from "@southwind-ai/shared";
+import { createAiRuntimeReadinessSources } from "./runtime-readiness-sources.js";
+import { createModuleAiPorts } from "./module-ai-port-factory.js";
+
+type MediaInput = Parameters<typeof registerMediaRuntimes>[0];
+type OperationServices = Parameters<
+  typeof createModuleAiPorts
+>[0]["operations"];
+
+export function composeSharedAiRuntime(
+  input: Pick<
+    MediaInput,
+    | "modules"
+    | "hosts"
+    | "runtime"
+    | "storage"
+    | "db"
+    | "resolveActor"
+    | "internalToken"
+  > & {
+    app: MediaInput["aiRouteApp"];
+    switches?: AiRuntimeSwitches;
+    features: readonly FeatureFlagDefinition[];
+    secret: string;
+    agent?: Parameters<typeof createAiRuntimeReadinessSources>[0]["agent"];
+  },
+) {
+  const aiArtifacts = new AiArtifactRuntime(
+    new AiArtifactCodec(input.secret),
+    input.hosts,
+    input.runtime,
+    input.features,
+    input.storage,
+    input.resolveActor,
+  );
+  registerAiArtifactRoutes(input.app, aiArtifacts, input.internalToken);
+  const grants = new ExecutionGrantStore();
+  const media = connectMediaRuntimes(input.internalToken, input.switches);
+  const { documentRemote, speechRemote, embeddingRemote } = media;
+  const readinessSources = createAiRuntimeReadinessSources({
+    agent: input.agent,
+    document: documentRemote,
+    speech: speechRemote,
+    embedding: embeddingRemote,
+    switches: input.switches,
+  });
+  const readinessTrustStore = new AiRuntimeReadinessTrustStoreV1();
+  const aiReadiness = createModuleAiOperationReadinessPort({
+    modules: input.modules,
+    sources: readinessSources,
+    trustStore: readinessTrustStore,
+    runtime: input.runtime,
+  });
+  const { documentFacadeWithOutput, speechFacade, embeddingFacade } =
+    registerMediaRuntimes({
+      ...media,
+      switches: input.switches,
+      modules: input.modules,
+      hosts: input.hosts,
+      runtime: input.runtime,
+      storage: input.storage,
+      db: input.db,
+      aiReadiness,
+      resolveActor: input.resolveActor,
+      aiArtifacts,
+      grants,
+      aiRouteApp: input.app,
+      internalToken: input.internalToken,
+    });
+
+  return {
+    aiArtifacts,
+    catalogReadiness: aiReadiness,
+    modulePorts(
+      agent: Pick<OperationServices, "agentFacade" | "agentRemote"> = {},
+    ) {
+      return createModuleAiPorts({
+        modules: input.modules,
+        runtime: input.runtime,
+        sources: readinessSources,
+        trustStore: readinessTrustStore,
+        operations: {
+          ...agent,
+          documentFacade: documentFacadeWithOutput,
+          documentRemote,
+          speechFacade,
+          speechRemote,
+          embeddingFacade,
+          modules: input.modules,
+        },
+      });
+    },
+  };
+}

package/template/apps/server/src/module-composition.test.ts

@@ -53,6 +53,28 @@ describe("Server Module Composition", () => {
     ).toThrow("API Route Handler Key 重复：POST /api/auth/users/:id/password");
   });
 
+  test("启动配置关闭的能力可省略 Handler，启用能力仍须完整注册", () => {
+    const module = fixture();
+    const feature = module.apiPermissions[0]!.featureKey!;
+    const input = { modules: [module], routes: [] };
+    expect(() => validateServerModuleComposition(input)).toThrow(
+      "缺少 Handler",
+    );
+    expect(() =>
+      validateServerModuleComposition({
+        ...input,
+        disabledFeatureKeys: new Set([feature]),
+      }),
+    ).not.toThrow();
+    expect(() =>
+      validateServerModuleComposition({
+        ...input,
+        routes: [{ method: "GET", path: "/api/unregistered" }],
+        disabledFeatureKeys: new Set([feature]),
+      }),
+    ).toThrow("未在 Manifest 声明");
+  });
+
   test("Host 注册实现必须在 Manifest 声明", () => {
     const app = new Elysia({ prefix: "/api" }).post(
       "/auth/users/:id/password",

package/template/apps/server/src/module-composition.ts

@@ -28,6 +28,7 @@ export interface ServerCompositionInput {
    * 产品、运维、认证与恢复入口仍必须进入 Manifest。
    */
   frameworkRoutes?: readonly string[];
+  disabledFeatureKeys?: ReadonlySet<string>;
   tasks?: readonly { key: string }[];
   tools?: ReadonlyMap<string, unknown>;
   aiOperations?: readonly string[];
@@ -50,7 +51,37 @@ export function validateServerModuleComposition(
     apiRoutes,
     input.frameworkRoutes ?? [],
   );
+  const disabledFeatures = disabledRuntimeFeatureClosure(
+    input.modules,
+    input.disabledFeatureKeys,
+  );
+  const registered = new Set(apiRoutes);
+  const outputPrefix = "/api/internal/ai/output-artifacts";
+  const hasOutputSink = input.routes.some(({ path }) =>
+    path.startsWith(outputPrefix),
+  );
+  const unavailableApiRoutes = new Set(
+    input.modules.flatMap((module) =>
+      module.apiPermissions
+        .filter(
+          ({ featureKey, path }) =>
+            (featureKey !== undefined && disabledFeatures.has(featureKey)) ||
+            (!hasOutputSink &&
+              featureKey === "system.ai-artifact" &&
+              path.startsWith(outputPrefix)),
+        )
+        .map(apiRouteKey)
+        .filter((key) => !registered.has(key)),
+    ),
+  );
+  const unavailableTools = disabledFeatures.has("system.agent")
+    ? new Set(
+        input.modules.flatMap((module) => module.tools.map(({ key }) => key)),
+      )
+    : undefined;
   validateModuleComposition(input.modules, {
+    unavailableApiRoutes,
+    unavailableTools,
     apiRoutes,
     tasks: (input.tasks || []).map(({ key }) => key),
     tools: [...(input.tools?.keys() || [])],
@@ -62,6 +93,23 @@ export function validateServerModuleComposition(
   }
 }
 
+function disabledRuntimeFeatureClosure(
+  modules: readonly ModuleManifest[],
+  disabledKeys: ReadonlySet<string> | undefined,
+) {
+  const disabled = new Set(disabledKeys);
+  const features = modules.flatMap((module) => module.features);
+  let previousSize = -1;
+  while (previousSize !== disabled.size) {
+    previousSize = disabled.size;
+    for (const feature of features) {
+      if (feature.dependencies?.some((key) => disabled.has(key)))
+        disabled.add(feature.key);
+    }
+  }
+  return disabled;
+}
+
 function validateHttpRouteRegistration(
   modules: readonly ModuleManifest[],
   registeredRoutes: readonly string[],

package/template/apps/server/src/module-host/ai-operation-port.ts

@@ -1,15 +1,15 @@
-// @windy-module system.agent begin
+// @windy-module system.media-runtime begin
 import type {
   ModuleAiOperationDefinition,
   ModuleManifest,
 } from "@southwind-ai/modules";
 import type {
+  ModuleAiArtifactRef,
   ModuleAiJsonValue,
+  ModuleAiRunReceipt,
   ModuleAiOperationPort,
 } from "@southwind-ai/server-sdk";
 import { ModuleAiOperationError } from "@southwind-ai/server-sdk";
-import type { AgentRunFacade } from "../agent/run-facade.js";
-import type { AgentRuntimePort } from "../agent/run-contracts.js";
 import type { DocumentRuntimePort } from "../document/contracts.js";
 import type { DocumentRunFacade } from "../document/facade.js";
 import type { EmbeddingFacade } from "../embedding/facade.js";
@@ -17,14 +17,48 @@ import type { RequestGuardContext } from "../guards.js";
 import type { SpeechRuntimePort } from "../speech/contracts.js";
 import type { SpeechRunFacade } from "../speech/facade.js";
 
+interface AgentOperationService {
+  start(
+    operationKey: string,
+    input: ModuleAiJsonValue,
+    idempotencyKey: string,
+    context: RequestGuardContext,
+    artifacts?: readonly ModuleAiArtifactRef[],
+    signal?: AbortSignal,
+  ): Promise<ModuleAiRunReceipt>;
+  verifyRunInput(
+    operationKey: string,
+    runId: string,
+    input: ModuleAiJsonValue,
+    context: RequestGuardContext,
+  ): Promise<void>;
+  authorizeRun(
+    operationKey: string,
+    runId: string,
+    context: RequestGuardContext,
+  ): Promise<unknown>;
+}
+
+interface AgentRunTransport {
+  result(runId: string, signal?: AbortSignal): Promise<Response>;
+  cancel(
+    runId: string,
+    reason?: string,
+    signal?: AbortSignal,
+  ): Promise<Response>;
+}
+
 export interface ModuleAiRuntimeServices {
-  readonly agentFacade: AgentRunFacade;
-  readonly agentRemote: AgentRuntimePort;
-  readonly documentFacade: DocumentRunFacade;
-  readonly documentRemote: DocumentRuntimePort;
-  readonly speechFacade: SpeechRunFacade;
-  readonly speechRemote: SpeechRuntimePort;
-  readonly embeddingFacade: EmbeddingFacade;
+  readonly agentFacade?: AgentOperationService;
+  readonly agentRemote?: AgentRunTransport;
+  readonly documentFacade?: DocumentRunFacade;
+  readonly documentRemote?: DocumentRuntimePort;
+  readonly speechFacade?: SpeechRunFacade;
+  readonly speechRemote?: SpeechRuntimePort;
+  readonly embeddingFacade?: EmbeddingFacade;
+  readonly requireFeature?: (
+    kind: "agent" | "document" | "speech" | "embedding",
+  ) => Promise<void>;
   readonly modules: readonly ModuleManifest[];
 }
 
@@ -45,7 +79,8 @@ export function createModuleAiOperationPort(
   return {
     async startAgent(input) {
       own(input.operationKey);
-      return services.agentFacade.start(
+      await services.requireFeature?.("agent");
+      return requireRuntime(services.agentFacade, "Agent").start(
         input.operationKey,
         input.input,
         input.idempotencyKey,
@@ -56,7 +91,8 @@ export function createModuleAiOperationPort(
     },
     async verifyAgentRun(input) {
       own(input.operationKey);
-      await services.agentFacade.verifyRunInput(
+      await services.requireFeature?.("agent");
+      await requireRuntime(services.agentFacade, "Agent").verifyRunInput(
         input.operationKey,
         input.runId,
         input.input,
@@ -65,7 +101,8 @@ export function createModuleAiOperationPort(
     },
     async startDocument(input) {
       own(input.operationKey);
-      return services.documentFacade.start(
+      await services.requireFeature?.("document");
+      return requireRuntime(services.documentFacade, "Document").start(
         input.operationKey,
         input.sources,
         input.options,
@@ -76,12 +113,13 @@ export function createModuleAiOperationPort(
     },
     async startSpeech(input) {
       own(input.operationKey);
+      await services.requireFeature?.("speech");
       const definition = ownSpeechDefinition(
         services.modules,
         moduleName,
         input.operationKey,
       );
-      return services.speechFacade.start(
+      return requireRuntime(services.speechFacade, "Speech").start(
         input.operationKey,
         input.source,
         input.options,
@@ -93,8 +131,9 @@ export function createModuleAiOperationPort(
     },
     async embed(input) {
       own(input.operationKey);
+      await services.requireFeature?.("embedding");
       return jsonValue(
-        await services.embeddingFacade.embed(
+        await requireRuntime(services.embeddingFacade, "Embedding").embed(
           input.operationKey,
           input.items,
           input.options,
@@ -106,51 +145,69 @@ export function createModuleAiOperationPort(
     },
     async result(input) {
       own(input.operationKey);
+      await services.requireFeature?.(input.kind);
       if (input.kind === "agent") {
-        await services.agentFacade.authorizeRun(
+        await requireRuntime(services.agentFacade, "Agent").authorizeRun(
           input.operationKey,
           input.runId,
           context,
         );
         return responseJson(
-          await services.agentRemote.result(input.runId, signal),
+          await requireRuntime(services.agentRemote, "Agent").result(
+            input.runId,
+            signal,
+          ),
         );
       }
       if (input.kind === "document") {
-        await services.documentFacade.authorizeRun(input.runId, context);
+        await requireRuntime(services.documentFacade, "Document").authorizeRun(
+          input.runId,
+          context,
+        );
         return responseJson(
-          await services.documentRemote.result(input.runId, signal),
+          await requireRuntime(services.documentRemote, "Document").result(
+            input.runId,
+            signal,
+          ),
         );
       }
-      services.speechFacade.authorizeRun(input.runId, context);
+      requireRuntime(services.speechFacade, "Speech").authorizeRun(
+        input.runId,
+        context,
+      );
       return responseJson(
-        await services.speechRemote.result(input.runId, signal),
+        await requireRuntime(services.speechRemote, "Speech").result(
+          input.runId,
+          signal,
+        ),
       );
     },
     async cancel(input) {
       own(input.operationKey);
+      await services.requireFeature?.(input.kind);
       let response: Response;
       if (input.kind === "agent") {
-        await services.agentFacade.authorizeRun(
+        await requireRuntime(services.agentFacade, "Agent").authorizeRun(
           input.operationKey,
           input.runId,
           context,
         );
-        response = await services.agentRemote.cancel(
+        response = await requireRuntime(services.agentRemote, "Agent").cancel(
           input.runId,
           input.reason,
           signal,
         );
       } else if (input.kind === "document") {
-        response = await services.documentFacade.cancel(
+        response = await requireRuntime(
+          services.documentFacade,
+          "Document",
+        ).cancel(input.runId, input.reason, context, signal);
+      } else {
+        requireRuntime(services.speechFacade, "Speech").authorizeRun(
           input.runId,
-          input.reason,
           context,
-          signal,
         );
-      } else {
-        services.speechFacade.authorizeRun(input.runId, context);
-        response = await services.speechRemote.cancel(
+        response = await requireRuntime(services.speechRemote, "Speech").cancel(
           input.runId,
           input.reason,
           signal,
@@ -161,6 +218,16 @@ export function createModuleAiOperationPort(
   };
 }
 
+function requireRuntime<T>(service: T | undefined, kind: string): T {
+  if (service === undefined) {
+    throw new ModuleAiOperationError(
+      "AI_OPERATION_UNAVAILABLE",
+      `${kind} Runtime 未装配`,
+    );
+  }
+  return service;
+}
+
 function ownSpeechDefinition(
   modules: readonly ModuleManifest[],
   moduleName: string,
@@ -235,4 +302,4 @@ function operationErrorCode(status: number, remoteCode: string) {
 function jsonValue(value: unknown): ModuleAiJsonValue {
   return JSON.parse(JSON.stringify(value)) as ModuleAiJsonValue;
 }
-// @windy-module system.agent end
+// @windy-module system.media-runtime end

package/template/apps/server/src/module-host/ai-operation-speech-normalize.test.ts

@@ -2,7 +2,7 @@
 import { expect, test } from "bun:test";
 import type { ModuleManifest } from "@southwind-ai/modules";
 import type { ModuleAiOperationReadinessV1 } from "@southwind-ai/server-sdk";
-import { ExecutionGrantStore } from "../agent/execution-grants.js";
+import { ExecutionGrantStore } from "../ai-runtime-security/execution-grants.js";
 import { createRequestGuardContext } from "../guards.js";
 import { initializeModuleHosts } from "../module-host.js";
 import { createServerRuntime } from "../runtime.js";

package/template/apps/server/src/module-host/http-runtime.ts

@@ -10,11 +10,13 @@ import type { ReportStagingService } from "../report-staging/service.js";
 // @windy-module system.storage end
 import type { RouteApp } from "../system/route-types.js";
 import type { SystemRepositories } from "../system/seed.js";
-// @windy-module system.agent begin
+// @windy-module system.media-runtime begin
 import type { RequestGuardContext } from "../guards.js";
 import type { AiArtifactRuntime } from "../ai-artifact/runtime.js";
 import type { ModuleAiOperationPort } from "@southwind-ai/server-sdk";
 import type { ModuleAiOperationReadinessPortV1 } from "@southwind-ai/server-sdk";
+// @windy-module system.media-runtime end
+// @windy-module system.agent begin
 import type { ModuleAiScreenshotIntakePortV1 } from "@southwind-ai/server-sdk";
 import type { ModuleAgentSessionMemoryPortV1 } from "@southwind-ai/server-sdk";
 import type { ModuleAuthoritativeSourceInvalidationPortV1 } from "@southwind-ai/server-sdk";
@@ -44,7 +46,7 @@ export function installModuleHttpRuntime(
     reportStaging?: ReportStagingService;
     // @windy-module system.storage end
     systemRepositories: SystemRepositories;
-    // @windy-module system.agent begin
+    // @windy-module system.media-runtime begin
     aiArtifacts?: AiArtifactRuntime;
     aiOperations?: (
       moduleName: string,
@@ -56,6 +58,8 @@ export function installModuleHttpRuntime(
       guardContext: RequestGuardContext,
       signal: AbortSignal,
     ) => ModuleAiOperationReadinessPortV1;
+    // @windy-module system.media-runtime end
+    // @windy-module system.agent begin
     screenshots?: (
       moduleName: string,
       guardContext: RequestGuardContext,
@@ -95,7 +99,7 @@ export function installModuleHttpRuntime(
     userDirectory: {
       repositories: context.systemRepositories,
     },
-    // @windy-module system.agent begin
+    // @windy-module system.media-runtime begin
     aiArtifacts: context.aiArtifacts
       ? (moduleName, guardContext, signal) =>
           context.aiArtifacts!.createModulePort(
@@ -114,6 +118,8 @@ export function installModuleHttpRuntime(
       : undefined,
     aiOperations: context.aiOperations,
     aiReadiness: context.aiReadiness,
+    // @windy-module system.media-runtime end
+    // @windy-module system.agent begin
     screenshots: context.screenshots,
     sessionMemory: context.sessionMemory,
     sourceInvalidation: context.sourceInvalidation,