create-windy 0.8.3 → 0.10.0

package/template/apps/server/scripts/check-dsh-platform-example.ts

@@ -0,0 +1,251 @@
+/** Synthetic acceptance: actual platform query Tool + official DSH Loop; no customer data or live model. */
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import {
+  createFoundationSnapshot,
+  loadSystemModules,
+} from "../src/foundation.ts";
+import { createServerRuntime } from "../src/runtime.ts";
+import { createSystemRepositories } from "../src/system/seed.ts";
+import { createSystemToolHandlers } from "../src/agent/routes.ts";
+import { GovernedToolRegistry } from "../src/agent/tool-registry.ts";
+import { RemoteAgentRuntime } from "../src/agent/remote-runtime.ts";
+import { toolDefinitions } from "../src/agent/run-definition-support.ts";
+import { platformBuiltinAgentSkills } from "../src/agent-skills/builtins.ts";
+
+const root = resolve(import.meta.dir, "../../..");
+const modules = loadSystemModules();
+const runtime = createServerRuntime(
+  { WINDY_DEV_ADMIN_TOKEN: "synthetic-example" },
+  { featureCatalog: modules.flatMap((module) => module.features) },
+);
+const context = await runtime.createGuardContext(
+  new Request("http://fixture/api/agent/runs", {
+    headers: { authorization: "Bearer synthetic-example" },
+  }),
+);
+const repositories = createSystemRepositories(
+  createFoundationSnapshot(undefined, modules),
+);
+const registry = new GovernedToolRegistry(
+  modules,
+  createSystemToolHandlers(repositories, runtime),
+  runtime,
+);
+const token = crypto.randomUUID() + crypto.randomUUID();
+let modelCalls = 0,
+  toolCalls = 0,
+  userCount = -1;
+const host = Bun.serve({
+  hostname: "127.0.0.1",
+  port: 0,
+  async fetch(request) {
+    const path = new URL(request.url).pathname;
+    if (path === "/api/internal/agent/tools/execute") {
+      assert.equal(request.headers.get("authorization"), `Bearer ${token}`);
+      const body = (await request.json()) as {
+        executionGrant: string;
+        toolKey: string;
+        arguments: Record<string, unknown>;
+      };
+      assert.equal(body.executionGrant, "synthetic-grant");
+      assert.equal(body.toolKey, "system.users.list");
+      const value = await registry.execute(
+        body.toolKey,
+        body.arguments,
+        context,
+      );
+      userCount = (value as { total: number }).total;
+      toolCalls++;
+      return Response.json({ value });
+    }
+    if (path !== "/v1/chat/completions")
+      return new Response(null, { status: 404 });
+    const body = (await request.json()) as {
+      messages: { role: string; content: unknown }[];
+      tools: { function: { name: string } }[];
+    };
+    modelCalls++;
+    assert(
+      JSON.stringify(body.messages).includes("平台工具查询") ||
+        JSON.stringify(body.messages).includes("当前会话实际可见的工具目录"),
+    );
+    const done = body.messages.at(-1)?.role === "tool";
+    const delta = done
+      ? {
+          content: JSON.stringify({
+            answer: `当前授权平台用户共${userCount}名`,
+          }),
+        }
+      : {
+          tool_calls: [
+            {
+              index: 0,
+              id: "synthetic-call",
+              type: "function",
+              function: {
+                name: body.tools[0]!.function.name,
+                arguments: '{"page":1,"pageSize":10}',
+              },
+            },
+          ],
+        };
+    return new Response(
+      `data: ${JSON.stringify({ choices: [{ delta, finish_reason: done ? "stop" : "tool_calls" }] })}\n\ndata: ${JSON.stringify({ choices: [], usage: { prompt_tokens: 100, completion_tokens: 10 } })}\n\ndata: [DONE]\n\n`,
+      { headers: { "content-type": "text/event-stream" } },
+    );
+  },
+});
+const outputRoot =
+  process.env.WINDY_DSH_EXAMPLE_OUTPUT ||
+  resolve(root, ".artifacts/dsh-platform-example");
+await mkdir(outputRoot, { recursive: true });
+const out = resolve(root, "apps/agent-server/.tmp/platform-example");
+await mkdir(out, { recursive: true });
+const entry = resolve(out, "entry.ts");
+await writeFile(
+  entry,
+  `import {startAgentServer} from ${JSON.stringify(resolve(root, "apps/agent-server/main.ts"))}; const a=await startAgentServer(0); console.log(JSON.stringify({port:a.server.address().port})); process.on("SIGTERM",()=>void a.close().then(()=>process.exit(0)));`,
+);
+const built = await Bun.build({
+  entrypoints: [entry],
+  target: "node",
+  outdir: out,
+  external: ["@deepseek-ai/*", "ajv", "zod", "sharp", "ws"],
+});
+assert(built.success, built.logs.map(String).join("\n"));
+const child = Bun.spawn(["node", resolve(out, "entry.js")], {
+  cwd: resolve(root, "apps/agent-server"),
+  env: {
+    ...process.env,
+    AGENT_SERVER_INTERNAL_TOKEN: token,
+    AGENT_RUNTIME_DATABASE_PATH: ":memory:",
+    QWEN_API_URL: `${host.url.origin}/v1`,
+    QWEN_MODEL: "synthetic-model",
+    AI_TOOL_HOST_URL: host.url.origin,
+    AI_PROVIDER_MAX_CONCURRENT_RUNS: "1",
+    AI_PROVIDER_MAX_QUEUE_DEPTH: "0",
+    AGENT_DSH_HOME: resolve(out, "unused-native-home"),
+  },
+  stdout: "pipe",
+  stderr: "inherit",
+});
+try {
+  const reader = child.stdout.getReader();
+  let ready = "";
+  while (!ready.includes("\n")) {
+    const chunk = await reader.read();
+    assert(!chunk.done, "agent startup failed");
+    ready += new TextDecoder().decode(chunk.value);
+  }
+  const port = JSON.parse(ready.split("\n")[0]!).port as number;
+  const remote = new RemoteAgentRuntime({
+    baseUrl: `http://127.0.0.1:${port}`,
+    internalToken: token,
+    toolHostUrl: host.url.origin,
+    compatibilityMode: "require-v1",
+  });
+  const fields = [
+    "instructions",
+    "user-prompt",
+    "tool-definitions",
+    "output-schema",
+    "provider-output",
+    "tool-results",
+  ] as const;
+  const created = await remote.start(
+    {
+      kind: "agent",
+      operationKey: "system.agent.example",
+      input: {},
+      instructions: platformBuiltinAgentSkills[0]!.markdown,
+      userPrompt: "按当前权限查询平台用户数，并形成可核验汇总",
+      inputModalities: ["text"],
+      requiredCapabilities: ["text-generation"],
+      artifacts: [],
+      outputSchemaKey: "system.agent.example.v1",
+      outputSchema: {
+        type: "object",
+        properties: { answer: { type: "string" } },
+        required: ["answer"],
+        additionalProperties: false,
+      },
+      allowedTools: toolDefinitions(modules, ["system.users.list"]),
+      limits: {
+        maxDurationSeconds: 30,
+        maxInputBytes: 65536,
+        maxOutputBytes: 65536,
+      },
+      providerEgress: {
+        mode: "configured-endpoint",
+        deploymentKey: "ai.openai-compatible",
+      },
+      providerDataPolicy: {
+        inputFields: [],
+        envelopeFields: fields.map((field) => ({
+          field,
+          classification: "internal",
+          dlpAction: "reject",
+        })),
+      },
+      toolNetworkPolicy: { mode: "forbidden" },
+      executionGrant: "synthetic-grant",
+      release: {
+        releaseId: "synthetic-release",
+        operationVersion: "1",
+        workflowVersion: "1",
+        promptVersion: "1",
+        routeVersion: "1",
+        outputSchemaVersion: "1",
+        toolSchemaVersion: "1",
+        manifestDigest: "1",
+      },
+      traceId: "synthetic-trace",
+      reporting: { actorId: context.actor.id, actorType: "user" },
+    },
+    "synthetic-platform-example",
+  );
+  const events = await remote.events(
+    created.runId,
+    0,
+    AbortSignal.timeout(45000),
+  );
+  const stream = await events.text();
+  assert.match(stream, /event: run.completed/);
+  assert.match(stream, /event: tool.completed/);
+  const response = await remote.result(created.runId);
+  const result = (await response.json()) as { output: { answer: string } };
+  assert.equal(result.output.answer, `当前授权平台用户共${userCount}名`);
+  assert.equal(toolCalls, 1);
+  assert.equal(modelCalls, 2);
+  assert(userCount > 0);
+  const evidence = {
+    synthetic: true,
+    skill: "windy-tool-query",
+    tool: "system.users.list",
+    modelCalls,
+    toolCalls,
+    userCount,
+    answer: result.output.answer,
+    checks: [
+      "actual-platform-tool-registry",
+      "manifest-schema-forwarding",
+      "official-dsh-loop",
+      "canonical-sse",
+      "typed-output",
+      "provider-synthetic",
+    ],
+  };
+  await writeFile(
+    resolve(outputRoot, "platform-example.json"),
+    JSON.stringify(evidence, null, 2),
+  );
+  console.log(JSON.stringify(evidence));
+  reader.releaseLock();
+} finally {
+  child.kill("SIGTERM");
+  await child.exited;
+  host.stop(true);
+  await rm(out, { recursive: true, force: true });
+}

package/template/apps/server/scripts/validate-module-composition-once.ts

@@ -1,4 +1,6 @@
 process.argv.push("--validate-module-composition");
 delete process.env.DATABASE_URL;
+// This isolated process validates declarations and handlers, not durable production startup.
+process.env.NODE_ENV = "test";
 
 await import("../src/index.js");

package/template/apps/server/scripts/validate-module-composition.ts

@@ -1,11 +1,15 @@
 import { spawnSync } from "node:child_process";
 
+const environment = { ...process.env };
+delete environment.PLATFORM_ENABLE_AI;
+delete environment.WINDY_ENVIRONMENT_PROFILE_FILE;
+
 const variants = [
-  { name: "default", env: { PLATFORM_ENABLE_AI: "false" } },
+  { name: "default", env: { PLATFORM_ENABLE_AI_RUNTIME: "false" } },
   {
     name: "ai-enabled",
     env: {
-      PLATFORM_ENABLE_AI: "true",
+      PLATFORM_ENABLE_AI_RUNTIME: "true",
       AGENT_SERVER_INTERNAL_TOKEN: "0123456789abcdef0123456789abcdef",
       AI_ARTIFACT_ENCRYPTION_SECRET: "abcdef0123456789abcdef0123456789",
     },
@@ -15,10 +19,10 @@ const variants = [
 for (const variant of variants) {
   const result = spawnSync(
     process.execPath,
-    ["run", "scripts/validate-module-composition-once.ts"],
+    ["--no-env-file", "run", "scripts/validate-module-composition-once.ts"],
     {
       cwd: process.cwd(),
-      env: { ...process.env, ...variant.env, DATABASE_URL: "" },
+      env: { ...environment, ...variant.env, DATABASE_URL: "" },
       stdio: "inherit",
     },
   );

package/template/apps/server/src/admin/routes.test.ts

@@ -48,8 +48,36 @@ describe("Windy 管理面准入", () => {
   });
 });
 
-async function invoke(actor: RequestActor): Promise<unknown> {
+// @windy-module system.agent begin
+test.each([false, true])(
+  "AI 装配为 %s 时同步管理菜单与页面授权",
+  async (enabled) => {
+    const result = (await invoke(adminActor(), enabled)) as {
+      menus: Array<{ key: string; children?: Array<{ key: string }> }>;
+      access: { features: Array<{ key: string; enabled: boolean }> };
+    };
+    const group = result.menus.find(({ key }) => key === "system.ai");
+    if (enabled) {
+      expect(group?.children?.map(({ key }) => key)).toContain(
+        "system.agent-workbench",
+      );
+    } else {
+      expect(group).toBeUndefined();
+      expect(result.access.features).toContainEqual(
+        expect.objectContaining({
+          key: "system.agent-workbench",
+          enabled: false,
+          allowed: false,
+        }),
+      );
+    }
+  },
+);
+// @windy-module system.agent end
+
+async function invoke(actor: RequestActor, enableAI = false): Promise<unknown> {
   const snapshot = createFoundationSnapshot();
+  snapshot.platform.enableAI = enableAI;
   const runtime = createServerRuntime(
     {},
     {

package/template/apps/server/src/admin/routes.ts

@@ -65,10 +65,28 @@ export function registerAdminBootstrapRoute(
     }
 
     const routes = source.modules.flatMap((module) => module.adminRoutes);
-    const routeKeys = new Set(routes.map(({ key }) => key));
+    const disabledAiFeatures = new Set(
+      source.snapshot.platform.enableAI
+        ? []
+        : source.modules.flatMap(({ menus }) =>
+            menus
+              .filter(({ key }) => key === "system.ai")
+              .flatMap(
+                ({ children }) =>
+                  children?.map(({ featureKey }) => featureKey) ?? [],
+              ),
+          ),
+    );
+    const routeKeys = new Set(
+      routes
+        .filter(({ featureKey }) => !disabledAiFeatures.has(featureKey))
+        .map(({ key }) => key),
+    );
     const resolvedFeatures = await Promise.all(
       source.snapshot.features.map((feature) =>
-        runtime.resolveFeature(guardContext, feature),
+        disabledAiFeatures.has(feature.key)
+          ? { ...feature, enabled: false, visible: "hidden" as const }
+          : runtime.resolveFeature(guardContext, feature),
       ),
     );
     return {

package/template/apps/server/src/agent/client-session/completion.ts

@@ -21,7 +21,7 @@ import {
   ClientAgentRequestError,
   parseClientAgentCompletion,
 } from "./request.js";
-import { ProviderInputGovernanceError } from "../provider-input-governance.js";
+import { ProviderInputGovernanceError } from "../../ai-runtime-security/provider-input-governance.js";
 import {
   enforceClientSessionAttemptAuthority,
   enforceClientSessionProviderBoundary,

package/template/apps/server/src/agent/client-session/manifest-admission.ts

@@ -10,7 +10,7 @@ import {
   governProviderInput,
   projectProviderInput,
   ProviderInputGovernanceError,
-} from "../provider-input-governance.js";
+} from "../../ai-runtime-security/provider-input-governance.js";
 import {
   buildRegisteredOperations,
   type RegisteredOperation,

package/template/apps/server/src/agent/client-session/request.ts

@@ -1,6 +1,6 @@
 import type { AiProviderDataPolicy } from "@southwind-ai/modules";
 import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
-import { governProviderEnvelope } from "../provider-input-governance.js";
+import { governProviderEnvelope } from "../../ai-runtime-security/provider-input-governance.js";
 
 const allowedKeys = new Set([
   "model",

package/template/apps/server/src/agent/context-version-routes.ts

@@ -16,7 +16,7 @@ import type {
   CommitAttemptContextInput,
 } from "./context-version-runtime.js";
 import { assertNoPrivateReasoning } from "./session-log/events.js";
-import { validInternalToken } from "./run-routes.js";
+import { validInternalToken } from "../ai-runtime-security/internal-token.js";
 
 const MAX_TEXT = 512;
 const PATH = "/internal/agent/context-versions";
@@ -80,9 +80,15 @@ export function registerUnavailableAgentContextVersionRoute(
   });
 }
 
-function parseInput(value: unknown, requestId: string):
+function parseInput(
+  value: unknown,
+  requestId: string,
+):
   | { phase: "prepare"; input: AttemptContextBaseInput }
-  | { phase: "abort"; input: AttemptContextBaseInput & { preparationId: string } }
+  | {
+      phase: "abort";
+      input: AttemptContextBaseInput & { preparationId: string };
+    }
   | { phase: "commit"; input: CommitAttemptContextInput } {
   if (!isRecord(value) || value.contractVersion !== 2) throw invalid();
   const base = parseBase(value, requestId);
@@ -91,7 +97,8 @@ function parseInput(value: unknown, requestId: string):
   if (value.phase === "abort") {
     return { phase: "abort", input: { ...base, preparationId } };
   }
-  if (value.phase !== "commit" || !isRecord(value.governedEnvelope)) throw invalid();
+  if (value.phase !== "commit" || !isRecord(value.governedEnvelope))
+    throw invalid();
   const provider = parseProvider(value.governedEnvelope.provider);
   if (!Array.isArray(value.governedEnvelope.messages)) throw invalid();
   const messages = value.governedEnvelope.messages.map(parseMessage);
@@ -105,7 +112,8 @@ function parseBase(
   value: Record<string, unknown>,
   requestId: string,
 ): AttemptContextBaseInput {
-  if (!Array.isArray(value.sources) || value.sources.length !== 1) throw invalid();
+  if (!Array.isArray(value.sources) || value.sources.length !== 1)
+    throw invalid();
   return {
     sessionId: text(value.sessionId),
     turnId: text(value.turnId),
@@ -150,16 +158,25 @@ function parseMessage(value: unknown): GovernedContextMessage {
 function parseOrigin(value: unknown): ContextMessageOrigin {
   if (!isRecord(value)) throw invalid();
   const type = value.type;
-  if (![
-    "instructions", "user-prompt", "artifact", "context-source",
-    "provider-output", "tool-receipt",
-  ].includes(String(type))) throw invalid();
+  if (
+    ![
+      "instructions",
+      "user-prompt",
+      "artifact",
+      "context-source",
+      "provider-output",
+      "tool-receipt",
+    ].includes(String(type))
+  )
+    throw invalid();
   return {
     type: type as ContextMessageOrigin["type"],
     sourceId: text(value.sourceId),
     sourceVersion: text(value.sourceVersion),
     digest: digest(value.digest),
-    ...(value.source === undefined ? {} : { source: parseReference(value.source) }),
+    ...(value.source === undefined
+      ? {}
+      : { source: parseReference(value.source) }),
   };
 }
 
@@ -190,7 +207,11 @@ function parseReference(value: unknown): ContextSourceReference {
         : { expiresAt: timestamp(value.validity.expiresAt) }),
       ...(value.validity.reason === undefined
         ? {}
-        : { reason: text(value.validity.reason) as ContextSourceReference["validity"]["reason"] }),
+        : {
+            reason: text(
+              value.validity.reason,
+            ) as ContextSourceReference["validity"]["reason"],
+          }),
     },
   };
 }
@@ -213,7 +234,8 @@ function positiveInteger(value: unknown) {
 }
 
 function digest(value: unknown) {
-  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw invalid();
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value))
+    throw invalid();
   return value;
 }
 
@@ -234,7 +256,9 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-function invalid() { return new Error("Context Version 请求无效"); }
+function invalid() {
+  return new Error("Context Version 请求无效");
+}
 
 function errorResponse(code: string, message: string, status: number) {
   return Response.json({ code, message, retryable: status >= 500 }, { status });

package/template/apps/server/src/agent/dsh-runtime-wire.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test";
+import { loadSystemModules } from "../foundation.js";
+import { toolDefinitions } from "./run-definition-support.js";
+import { parseRemoteStatus } from "./remote-runtime-response.js";
+
+test("Operation将Manifest工具输入Schema传到DSH，缺失Schema时拒绝装配", () => {
+  const modules = loadSystemModules();
+  const [tool] = toolDefinitions(modules, ["system.users.list"]);
+  expect(tool?.inputSchema).toMatchObject({ type: "object" });
+  const missing = modules.map((module) => ({ ...module, jsonSchemas: [] }));
+  expect(() => toolDefinitions(missing, ["system.users.list"])).toThrow(
+    "输入 Schema",
+  );
+});
+
+test("Node运行中状态的null终态不会被误解析为已完成，终态仍必须匹配事件", () => {
+  expect(
+    parseRemoteStatus({
+      runId: "run_synthetic",
+      status: "running",
+      lastSequence: 1,
+      terminalEvent: null,
+    }),
+  ).toEqual({ runId: "run_synthetic", status: "running", lastSequence: 1 });
+  expect(() =>
+    parseRemoteStatus({
+      runId: "run_synthetic",
+      status: "completed",
+      lastSequence: 1,
+      terminalEvent: null,
+    }),
+  ).toThrow();
+});

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

@@ -0,0 +1,41 @@
+import type { ModuleManifest } from "@southwind-ai/modules";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { bootstrapAgentSkills } from "../agent-skills/bootstrap.js";
+import { platformBuiltinAgentSkills } from "../agent-skills/builtins.js";
+import type { AgentSkillService } from "../agent-skills/service.js";
+import type { GovernedToolRegistry } from "./tool-registry.js";
+import type { createServerRuntime } from "../runtime.js";
+
+type Runtime = ReturnType<typeof createServerRuntime>;
+interface Governance {
+  readonly skills: AgentSkillService;
+  tools?: GovernedToolRegistry;
+}
+// Runtime-scoped ownership lets asynchronous platform startup precede Tool Host binding.
+const runtimes = new WeakMap<Runtime, Governance>();
+export async function prepareAgentGovernance(input: {
+  runtime: Runtime;
+  modules: readonly ModuleManifest[];
+  db?: NodePgDatabase;
+}) {
+  const previous = runtimes.get(input.runtime);
+  if (previous) return previous;
+  const governance: Governance = {
+    skills: bootstrapAgentSkills({
+      ...input,
+      tools: () => governance.tools,
+    }),
+  };
+  await governance.skills.registerBuiltins(platformBuiltinAgentSkills, {
+    tenantId: "single-tenant",
+  });
+  runtimes.set(input.runtime, governance);
+  return governance;
+}
+export function bindAgentGovernanceTools(
+  runtime: Runtime,
+  tools: GovernedToolRegistry,
+) {
+  const governance = runtimes.get(runtime);
+  if (governance) governance.tools = tools;
+}

package/template/apps/server/src/agent/remote-runtime-response.ts

@@ -36,7 +36,7 @@ export function parseRemoteStatus(value: unknown): AgentRuntimeStatusResponse {
     throw new Error("Agent Runtime 状态字段无效");
   }
   const terminalEvent =
-    value.terminalEvent === undefined
+    value.terminalEvent === undefined || value.terminalEvent === null
       ? undefined
       : parseTerminalEvent(value.terminalEvent, runId);
   const terminalStatus = ["completed", "failed", "cancelled"].includes(status);

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

@@ -24,6 +24,7 @@ export interface AgentRuntimeOperation {
     key: string;
     label: string;
     description: string;
+    inputSchema?: ModuleAiJsonValue;
     approval: "none" | "required";
     idempotency: "none" | "supported" | "required";
     approvalTimeoutSeconds?: number;

package/template/apps/server/src/agent/run-definition-support.ts

@@ -10,10 +10,19 @@ export function toolDefinitions(
   const tools = new Map(
     modules.flatMap(({ tools }) => tools.map((tool) => [tool.key, tool])),
   );
+  const schemas = new Map(
+    modules.flatMap(({ jsonSchemas }) =>
+      (jsonSchemas ?? []).map(({ key, schema }) => [key, schema] as const),
+    ),
+  );
   return allowedKeys.map((key) => {
     const tool = tools.get(key);
     if (!tool) throw new Error(`AI Operation 引用了未知 Tool：${key}`);
+    const inputSchema = schemas.get(tool.inputSchemaKey);
+    if (!inputSchema)
+      throw new Error(`AI Operation Tool 缺少输入 Schema：${key}`);
     return {
+      inputSchema,
       key: tool.key,
       label: tool.label,
       description: tool.description,

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

@@ -35,7 +35,7 @@ import {
   mapAgentRuntimeError,
 } from "./run-definition-support.js";
 import { AgentRunFacadeError } from "./run-errors.js";
-import { scopedRuntimeIdempotencyKey } from "./idempotency-key.js";
+import { scopedRuntimeIdempotencyKey } from "../ai-runtime-security/idempotency-key.js";
 import { verifyCommittedRunInput } from "./run-input-verification.js";
 import {
   buildRegisteredOperations,

package/template/apps/server/src/agent/run-input-verification.ts

@@ -4,7 +4,7 @@ import type { RequestGuardContext } from "../guards.js";
 import {
   projectProviderInput,
   ProviderInputGovernanceError,
-} from "./provider-input-governance.js";
+} from "../ai-runtime-security/provider-input-governance.js";
 import {
   AgentRunAuthorizationError,
   type AgentRunAuthorizationStore,

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

@@ -4,7 +4,7 @@ import {
   required,
   isRecord,
 } from "./run-route-response.js";
-import { timingSafeEqual } from "node:crypto";
+import { validInternalToken } from "../ai-runtime-security/internal-token.js";
 import type { RequestGuardContext } from "../guards.js";
 import type { RouteApp } from "../system/routes.js";
 import type { AgentRunFacade } from "./run-facade.js";
@@ -326,16 +326,3 @@ async function completeSessionRun(
   }
   await port.completeForRun({ sessionId, runId, outcome, context });
 }
-
-export function validInternalToken(
-  request: Request,
-  expected: string,
-): boolean {
-  const provided = request.headers
-    .get("authorization")
-    ?.replace(/^Bearer /, "");
-  if (!provided || !expected) return false;
-  const left = Buffer.from(provided);
-  const right = Buffer.from(expected);
-  return left.length === right.length && timingSafeEqual(left, right);
-}

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

@@ -6,7 +6,7 @@ import {
   governProviderInput,
   projectProviderInput,
   ProviderInputGovernanceError,
-} from "./provider-input-governance.js";
+} from "../ai-runtime-security/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";