create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/runtime/context.nodecheck.ts

@@ -0,0 +1,241 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  contextState,
+  runtime,
+  request,
+  input,
+  endpoint,
+  providerCalls,
+} from "./runtime-test-fixtures.js";
+import { configFromEnvironment } from "./config.js";
+test("context is reauthorized and committed against exact provider request on every DSH attempt", async () => {
+  const handler = runtime({ AGENT_CONTEXT_HOST_URL: endpoint });
+  contextState.valid = true;
+  contextState.revokeAfterCommit = false;
+  contextState.phases.length = 0;
+  try {
+    const body = input(true);
+    body.longSession = {
+      sessionId: "session_example",
+      turnId: "turn_example",
+      sources: [
+        { moduleKey: "system.agent", kind: "recent-event", id: "event-1" },
+      ],
+    };
+    const start = await handler(request("/api/agent/runs", "POST", body));
+    const run = (await start!.json()) as { eventsUrl: string };
+    const events = await handler(request(run.eventsUrl));
+    assert.match(await events!.text(), /event: run.completed/);
+    assert.deepEqual(contextState.phases, [
+      "prepare",
+      "commit",
+      "prepare",
+      "commit",
+    ]);
+  } finally {
+    await handler.close();
+  }
+});
+test("revoked source prevents next DSH model call rather than silently using old context", async () => {
+  const handler = runtime({ AGENT_CONTEXT_HOST_URL: endpoint }),
+    beforeCalls = providerCalls;
+  contextState.valid = true;
+  contextState.revokeAfterCommit = true;
+  contextState.phases.length = 0;
+  try {
+    const body = input(true);
+    body.longSession = {
+      sessionId: "session_revoked",
+      turnId: "turn_revoked",
+      sources: [
+        { moduleKey: "system.agent", kind: "recent-event", id: "event-1" },
+      ],
+    };
+    const start = await handler(request("/api/agent/runs", "POST", body));
+    const run = (await start!.json()) as { eventsUrl: string };
+    const events = await handler(request(run.eventsUrl));
+    const text = await events!.text();
+    assert.match(text, /event: run.failed/);
+    assert.match(text, /RUNTIME_UNAVAILABLE/);
+    assert.equal(providerCalls, beforeCalls + 1);
+  } finally {
+    contextState.valid = true;
+    contextState.revokeAfterCommit = false;
+    await handler.close();
+  }
+});
+test("configured tokenizer admits large image wire payload using serving template token count", async () => {
+  const handler = runtime({
+    AI_PROVIDER_TOKENIZE_PATH: "/tokenize",
+    AI_PROVIDER_CONTEXT_TOKENS: "4096",
+  });
+  try {
+    const response = await handler.handleNativeCompletion(
+      new Request("http://runtime/internal/boundary/v1/chat/completions", {
+        method: "POST",
+        body: JSON.stringify({
+          stream: true,
+          messages: [
+            {
+              role: "user",
+              content: [
+                { type: "text", text: "描述图片" },
+                {
+                  type: "image_url",
+                  image_url: {
+                    url: `data:image/png;base64,${"A".repeat(40000)}`,
+                  },
+                },
+              ],
+            },
+          ],
+        }),
+      }),
+      { actorId: "actor", signal: AbortSignal.timeout(5000) },
+    );
+    assert.equal(response.status, 200);
+    await response.text();
+  } finally {
+    await handler.close();
+  }
+});
+test("provider settings preserve private egress and generation contracts", () => {
+  assert.equal(
+    configFromEnvironment({ AI_PROVIDER_CAPACITY_PROFILE: "local" })
+      .concurrency,
+    1,
+  );
+  assert.equal(
+    configFromEnvironment({ AI_PROVIDER_CAPACITY_PROFILE: "remote" })
+      .concurrency,
+    3,
+  );
+  assert.equal(
+    configFromEnvironment({
+      AI_PROVIDER_CAPACITY_PROFILE: "local",
+      AI_PROVIDER_MAX_CONCURRENT_RUNS: "2",
+    }).concurrency,
+    2,
+  );
+  assert.throws(
+    () => configFromEnvironment({ AI_PROVIDER_CAPACITY_PROFILE: "unknown" }),
+    /CAPACITY_PROFILE/,
+  );
+  assert.equal(
+    configFromEnvironment({
+      AI_PROVIDER_REQUEST_TIMEOUT_MS: "1000",
+      AI_PROVIDER_MAX_DURATION_SECONDS: "2",
+    }).requestTimeoutMs,
+    1000,
+  );
+  assert.throws(
+    () => configFromEnvironment({ AI_PROVIDER_REQUEST_TIMEOUT_MS: "999" }),
+    /TIMEOUT/,
+  );
+  assert.throws(
+    () => configFromEnvironment({ AI_PROVIDER_MAX_DURATION_SECONDS: "301" }),
+    /DURATION/,
+  );
+  assert.throws(
+    () => configFromEnvironment({ QWEN_API_URL: "http://example.com/v1" }),
+    /private/,
+  );
+  assert.throws(
+    () => configFromEnvironment({ QWEN_API_URL: "https://example.com/v1" }),
+    /authorized/,
+  );
+  assert.doesNotThrow(() =>
+    configFromEnvironment({ QWEN_API_URL: "http://192.168.1.2/v1" }),
+  );
+  const config = configFromEnvironment({
+    AI_PROVIDER_THINKING_PARAMETER: "chat-template",
+    AI_PROVIDER_ENABLE_THINKING: "false",
+    AI_PROVIDER_PRESENCE_PENALTY: "1.5",
+    AI_PROVIDER_TOP_K: "20",
+  });
+  assert.deepEqual(config.generation, {
+    chat_template_kwargs: { enable_thinking: false },
+    presence_penalty: 1.5,
+    top_k: 20,
+  });
+  assert.deepEqual(
+    configFromEnvironment({ AI_PROVIDER_ENABLE_THINKING: "true" }).generation,
+    { enable_thinking: true },
+  );
+  assert.throws(
+    () => configFromEnvironment({ AI_PROVIDER_TOP_K: "1.2" }),
+    /invalid/,
+  );
+});
+test("native context admission uses OpenAI overflow contract without changing canonical errors", async () => {
+  const handler = runtime({ AI_PROVIDER_CONTEXT_TOKENS: "4096" }),
+    beforeCalls = providerCalls;
+  try {
+    const response = await handler.handleNativeCompletion(
+      new Request("http://runtime/internal/boundary/v1/chat/completions", {
+        method: "POST",
+        body: JSON.stringify({
+          stream: true,
+          messages: [{ role: "user", content: "x".repeat(10000) }],
+        }),
+      }),
+      { actorId: "actor", signal: AbortSignal.timeout(5000) },
+    );
+    assert.equal(response.status, 400);
+    assert.deepEqual(await response.json(), {
+      error: {
+        code: "context_length_exceeded",
+        type: "invalid_request_error",
+        message: "Input exceeds the context window (conservative admission)",
+      },
+    });
+    assert.equal(providerCalls, beforeCalls);
+    const body = input();
+    body.userPrompt = "x".repeat(10000);
+    const start = await handler(request("/api/agent/runs", "POST", body));
+    const run = (await start!.json()) as { eventsUrl: string };
+    const events = await handler(request(run.eventsUrl));
+    const text = await events!.text();
+    assert.match(text, /"code":"CONTEXT_LIMIT"/);
+    assert.doesNotMatch(text, /context_length_exceeded/);
+  } finally {
+    await handler.close();
+  }
+});
+test("unset serving capacity does not turn the DSH profile window into a hard model limit", async () => {
+  const handler = runtime({ DSH_CONTEXT_WINDOW: "4096" }),
+    beforeCalls = providerCalls;
+  try {
+    const prompt = "x".repeat(40000);
+    const response = await handler.handleNativeCompletion(
+      new Request("http://runtime/internal/boundary/v1/chat/completions", {
+        method: "POST",
+        body: JSON.stringify({
+          stream: true,
+          messages: [{ role: "user", content: prompt }],
+        }),
+      }),
+      { actorId: "actor", signal: AbortSignal.timeout(5000) },
+    );
+    assert.equal(response.status, 200);
+    await response.text();
+    const body = input();
+    body.userPrompt = prompt;
+    const start = await handler(request("/api/agent/runs", "POST", body));
+    const run = (await start!.json()) as { eventsUrl: string };
+    const events = await handler(request(run.eventsUrl));
+    assert.match(await events!.text(), /event: run.completed/);
+    assert.equal(providerCalls, beforeCalls + 2);
+    body.limits.maxInputTokens = 1000;
+    const limited = await handler(
+      request("/api/agent/runs", "POST", body, "explicit-input-budget"),
+    );
+    const denied = (await limited!.json()) as { eventsUrl: string };
+    const failure = await handler(request(denied.eventsUrl));
+    assert.match(await failure!.text(), /BUDGET_EXCEEDED/);
+    assert.equal(providerCalls, beforeCalls + 2);
+  } finally {
+    await handler.close();
+  }
+});

package/template/apps/agent-server/runtime/contracts.ts

@@ -0,0 +1,201 @@
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+
+export const limitsSchema = z
+  .object({
+    maxDurationSeconds: z.number().int().min(1).max(300).default(60),
+    maxInputBytes: z.number().int().min(1024).max(67108864).default(1048576),
+    maxOutputBytes: z.number().int().min(1024).max(16777216).default(1048576),
+    maxModelAttempts: z.number().int().min(1).max(500).optional(),
+    maxToolCalls: z.number().int().min(0).max(100000).optional(),
+    maxSubagents: z.number().int().min(0).max(10000).optional(),
+    maxParallelism: z.number().int().min(1).max(256).optional(),
+    maxInputTokens: z.number().int().positive().optional(),
+    maxOutputTokens: z.number().int().positive().optional(),
+    maxCostMicros: z.number().int().nonnegative().optional(),
+  })
+  .passthrough();
+export const policySchema = z.object({
+  inputFields: z
+    .array(
+      z.object({
+        jsonPointer: z.string(),
+        classification: z.string(),
+        dlpAction: z.enum(["reject", "redact"]),
+      }),
+    )
+    .default([]),
+  envelopeFields: z
+    .array(
+      z.object({
+        field: z.string(),
+        classification: z.string(),
+        dlpAction: z.enum(["reject", "redact"]),
+      }),
+    )
+    .default([]),
+});
+export const runSchema = z
+  .object({
+    kind: z.literal("agent").default("agent"),
+    operationKey: z.string().min(1).max(200),
+    input: z.unknown(),
+    instructions: z.string().default(""),
+    userPrompt: z.string().min(1),
+    inputModalities: z
+      .array(z.enum(["text", "image", "audio", "video", "document"]))
+      .default(["text"]),
+    requiredCapabilities: z.array(z.string()).max(32).default([]),
+    artifacts: z
+      .array(
+        z.object({
+          value: z.string(),
+          mediaType: z.string(),
+          byteSize: z.number(),
+          sha256: z.string(),
+        }),
+      )
+      .max(16)
+      .default([]),
+    outputSchema: z.record(z.string(), z.unknown()).nullish(),
+    outputSchemaKey: z.string().default(""),
+    allowedTools: z
+      .array(
+        z.object({
+          key: z.string().min(1),
+          label: z.string(),
+          description: z.string(),
+          inputSchema: z.record(z.string(), z.unknown()),
+          approval: z.enum(["none", "required"]).default("none"),
+          approvalTimeoutSeconds: z.number().optional(),
+          idempotency: z.string().optional(),
+        }),
+      )
+      .max(64)
+      .default([]),
+    limits: limitsSchema.default(() => limitsSchema.parse({})),
+    providerEgress: z.object({
+      mode: z.enum(["forbidden", "configured-endpoint"]),
+      deploymentKey: z.string().optional(),
+    }),
+    providerDataPolicy: policySchema,
+    toolNetworkPolicy: z.object({ mode: z.literal("forbidden") }),
+    executionGrant: z.string().default(""),
+    toolHostUrl: z.string().default(""),
+    modelPin: z
+      .object({ deploymentKey: z.string(), model: z.string() })
+      .nullish(),
+    readinessPin: z.unknown().optional(),
+    release: z.record(z.string(), z.unknown()),
+    outputPolicy: z
+      .object({
+        visibility: z.enum(["public", "internal"]).default("public"),
+        encryptionKeyId: z.string().nullish(),
+      })
+      .default({ visibility: "public" }),
+    traceId: z.string().max(160).default(""),
+    reporting: z.record(z.string(), z.unknown()).nullish(),
+    longSession: z
+      .object({
+        sessionId: z
+          .string()
+          .regex(/^session_[A-Za-z0-9_-]+$/)
+          .max(80),
+        turnId: z
+          .string()
+          .regex(/^turn_[A-Za-z0-9_-]+$/)
+          .max(96),
+        caseId: z.string().min(1).max(160).nullish(),
+        sources: z
+          .array(
+            z.object({
+              moduleKey: z.string().min(1).max(160),
+              kind: z.string().min(1),
+              id: z.string().min(1).max(200),
+            }),
+          )
+          .min(1)
+          .max(100),
+      })
+      .nullish(),
+  })
+  .strict();
+export type RunRequest = z.infer<typeof runSchema>;
+export type ProviderPolicy = z.infer<typeof policySchema>;
+export type RunStatus =
+  | "accepted"
+  | "running"
+  | "awaiting-approval"
+  | "completed"
+  | "failed"
+  | "cancelled";
+export type CanonicalEvent = Record<string, unknown> & {
+  type: string;
+  sequence: number;
+  runId: string;
+};
+export class SafeError extends Error {
+  constructor(
+    readonly code: string,
+    message: string,
+    readonly retryable = false,
+    readonly status = 409,
+  ) {
+    super(message);
+  }
+}
+export function digest(value: unknown): string {
+  return `sha256:${createHash("sha256")
+    .update(typeof value === "string" ? value : JSON.stringify(value))
+    .digest("hex")}`;
+}
+export function errorValue(error: unknown) {
+  const safe =
+    error instanceof SafeError
+      ? error
+      : new SafeError("RUNTIME_UNAVAILABLE", "Agent 运行暂不可用", true, 503);
+  return {
+    code: safe.code,
+    message: safe.message,
+    retryable: safe.retryable,
+    requestId: `request_${randomUUID().replaceAll("-", "")}`,
+  };
+}
+export function authorized(request: Request, token: string): boolean {
+  const provided = Buffer.from(request.headers.get("authorization") ?? "");
+  const expected = Buffer.from(`Bearer ${token}`);
+  return (
+    token.length >= 16 &&
+    provided.length === expected.length &&
+    timingSafeEqual(provided, expected)
+  );
+}
+export function json(value: unknown, status = 200): Response {
+  return Response.json(value, { status });
+}
+export async function readJson(
+  request: Request,
+  limit = 2097152,
+): Promise<unknown> {
+  const reader = request.body?.getReader();
+  if (!reader) throw new SafeError("INVALID_INPUT", "请求为空", false, 400);
+  const parts: Uint8Array[] = [];
+  let bytes = 0;
+  try {
+    for (;;) {
+      const next = await reader.read();
+      if (next.done) break;
+      bytes += next.value.byteLength;
+      if (bytes > limit)
+        throw new SafeError("INVALID_INPUT", "请求超过上限", false, 413);
+      parts.push(next.value);
+    }
+  } finally {
+    await reader.cancel();
+  }
+  try {
+    return JSON.parse(Buffer.concat(parts).toString("utf8"));
+  } catch {
+    throw new SafeError("INVALID_INPUT", "请求格式无效", false, 400);
+  }
+}

package/template/apps/agent-server/runtime/dsh-engine.ts

@@ -0,0 +1,198 @@
+import { ENGINE_ID } from "./compatibility.js";
+import { Context } from "@deepseek-ai/cordis";
+import AgentRegistry from "@deepseek-ai/dsh-agent";
+import AgentLoop from "@deepseek-ai/dsh-agent-loop";
+import SessionStore, { SessionId } from "@deepseek-ai/dsh-session";
+import SessionProjections from "@deepseek-ai/dsh-session-projection";
+import LlmRuntime, { MessageId } from "@deepseek-ai/dsh-llm";
+import ToolRuntime from "@deepseek-ai/dsh-tools";
+import * as NativeToolExecutor from "@deepseek-ai/dsh-tool-executor-native";
+import SystemPrompt from "@deepseek-ai/dsh-system-prompt";
+import { SafeError, digest, type RunRequest } from "./contracts.js";
+import { GovernedModelAdapter, type ExecutionBudget } from "./model-plugin.js";
+import { registerBusinessTools, type ToolSource } from "./tool-plugin.js";
+import type { RuntimeConfig } from "./config.js";
+import type { RuntimeStore } from "./store.js";
+import { protectOutput } from "./internal-output.js";
+import { prepareImages } from "./artifacts.js";
+import { validateStructuredOutput } from "./output-validation.js";
+import type { ModelCapacity } from "./capacity.js";
+
+export async function executeDshRun(
+  runId: string,
+  request: RunRequest,
+  config: RuntimeConfig,
+  store: RuntimeStore,
+  signal: AbortSignal,
+  capacity: ModelCapacity,
+) {
+  if (
+    request.inputModalities.some(
+      (value) => !config.inputModalities.includes(value),
+    )
+  )
+    throw new SafeError(
+      "MODEL_ROUTE_UNAVAILABLE",
+      "直接多模态 Operation 尚未通过当前模型验收，请使用工作台文件能力",
+    );
+  if (
+    request.requiredCapabilities.some(
+      (value) => !config.capabilities.includes(value),
+    )
+  )
+    throw new SafeError(
+      "MODEL_ROUTE_UNAVAILABLE",
+      "当前运行时不支持要求的模型能力",
+    );
+  if (request.limits.maxCostMicros !== undefined)
+    throw new SafeError("BUDGET_EXCEEDED", "当前模型未配置可核验的费用计量");
+  // Assert encryption identity before sending even one byte to the provider.
+  protectOutput(config.internalOutputSecret, runId, request.outputPolicy, null);
+  const ctx = new Context();
+  const fibers: { dispose(): Promise<void> }[] = [];
+  const budget: ExecutionBudget = {
+    attempts: 0,
+    toolCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+  };
+  const sources: ToolSource[] = [];
+  const images = await prepareImages(request, config, signal);
+  let output = "",
+    failure: unknown,
+    succeeded = false;
+  const adapter = new GovernedModelAdapter(
+    config,
+    request,
+    runId,
+    store,
+    budget,
+    new Map(
+      images.map((image) => [
+        image.block.attachment.attachmentId,
+        image.dataUrl,
+      ]),
+    ),
+  );
+  const originalStream = adapter.stream.bind(adapter);
+  adapter.stream = async function* (options) {
+    const release = capacity.acquire();
+    try {
+      yield* originalStream(options);
+    } finally {
+      release();
+    }
+  };
+  try {
+    for (const plugin of [
+      LlmRuntime,
+      SessionStore,
+      SessionProjections,
+      AgentRegistry,
+    ])
+      fibers.push(await ctx.plugin(plugin));
+    fibers.push(
+      await ctx.plugin(SystemPrompt, {
+        includeHarnessIdentity: false,
+        includeRuntimeContext: false,
+        personaPrefix: `${request.instructions}${request.outputSchema ? `\n最终答案必须只包含符合以下 JSON Schema 的 JSON，不使用 Markdown 代码块：\n${JSON.stringify(request.outputSchema)}` : ""}`,
+      }),
+    );
+    fibers.push(await ctx.plugin(ToolRuntime));
+    fibers.push(await ctx.plugin(NativeToolExecutor));
+    fibers.push(
+      await ctx.plugin(AgentLoop, { maxParallelToolCalls: 1, agents: [] }),
+    );
+    ctx.llm.registerAdapter(["windy"], adapter);
+    registerBusinessTools(ctx, request, runId, config, store, budget, sources);
+    ctx.on("session/event", (_session, event) => {
+      if (event.type === "assistant/message")
+        output = event.data.message.content
+          .filter((block) => block.type === "text")
+          .map((block) => block.text)
+          .join("");
+      if (event.type === "turn/end") {
+        succeeded = event.data.reason.kind === "completed";
+        if (event.data.reason.kind === "error")
+          failure = new SafeError("PROVIDER_UNAVAILABLE", "模型执行失败", true);
+        if (event.data.reason.kind === "max-tokens")
+          failure = new SafeError("OUTPUT_TRUNCATED", "模型输出达到长度上限");
+      }
+    });
+    const handle = await ctx.agents.create({
+      sessionId: SessionId(runId),
+      signal,
+      agentOptions: {
+        provider: "windy",
+        model: config.model,
+        maxTokens: Math.min(
+          config.maxOutputTokens,
+          request.limits.maxOutputTokens ?? config.maxOutputTokens,
+        ),
+      },
+    });
+    const cancel = () => handle.agent.cancel({ kind: "user" });
+    signal.addEventListener("abort", cancel, { once: true });
+    try {
+      signal.throwIfAborted();
+      handle.agent.followup({
+        id: MessageId(`prompt_${runId}`),
+        role: "user",
+        source: { kind: "user" },
+        content: [
+          { type: "text", text: request.userPrompt },
+          ...images.map((image) => image.block),
+        ],
+      });
+      await handle.agent.whenIdle();
+      signal.throwIfAborted();
+      if (budget.failure) throw budget.failure;
+      if (!succeeded)
+        throw (
+          failure ??
+          new SafeError("RUNTIME_UNAVAILABLE", "DSH 未完成当前任务", true)
+        );
+      let value: unknown = { text: output };
+      if (request.outputSchema) {
+        value = validateStructuredOutput(output, request.outputSchema, {
+          runId,
+          operationKey: request.operationKey,
+          outputSchemaKey: request.outputSchemaKey,
+        });
+      }
+      const attestation = {
+        schemaVersion: 1,
+        generation: 1,
+        deploymentDigest: digest({
+          modelPolicy: {
+            model: config.model,
+            deploymentKey: config.deploymentKey,
+            endpointDigest: digest(config.baseUrl),
+          },
+          operationRelease: request.release,
+          engineId: ENGINE_ID,
+        }),
+        citations: sources.map((source) => ({
+          id: `citation_${digest({ runId, toolCallId: source.toolCallId, snapshotDigest: source.snapshotDigest }).slice(7)}`,
+          toolCallId: source.toolCallId,
+          toolKey: source.toolKey,
+          snapshotDigest: source.snapshotDigest,
+        })),
+      };
+      return {
+        output: protectOutput(
+          config.internalOutputSecret,
+          runId,
+          request.outputPolicy,
+          value,
+        ),
+        attestation,
+      };
+    } finally {
+      signal.removeEventListener("abort", cancel);
+      await handle.dispose();
+    }
+  } finally {
+    for (const fiber of fibers.reverse()) await fiber.dispose();
+  }
+}