create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/runtime/model-payload.ts

@@ -0,0 +1,97 @@
+import type { GenerateOptions } from "@deepseek-ai/dsh-llm";
+import type { RuntimeConfig } from "./config.js";
+import type { RunRequest } from "./contracts.js";
+import { SafeError } from "./contracts.js";
+import type { RuntimeStore } from "./store.js";
+import type { ExecutionBudget } from "./model-plugin.js";
+import { HostContextPlugin } from "./context-plugin.js";
+import { governProvider } from "./governance.js";
+import { wireMessage } from "./model-wire.js";
+import { admitProviderContext } from "./context-budget.js";
+export async function prepareModelPayload(
+  config: RuntimeConfig,
+  request: RunRequest,
+  runId: string,
+  store: RuntimeStore,
+  budget: ExecutionBudget,
+  options: GenerateOptions,
+  images: ReadonlyMap<string, string>,
+  remainingTokens: number,
+) {
+  const context = new HostContextPlugin(
+    config,
+    request,
+    runId,
+    `${runId}_attempt_${budget.attempts}`,
+    options.signal,
+  );
+  const prepared = await context.prepare(
+    options.messages.map((message) => wireMessage(message, images)),
+  );
+  try {
+    const governed = governProvider(
+      prepared.messages,
+      (options.tools ?? []).map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+        },
+      })),
+      request.outputSchema,
+      request.providerDataPolicy,
+      store,
+      {
+        runId,
+        operationKey: request.operationKey,
+        deploymentKey: config.deploymentKey,
+        attempt: budget.attempts,
+      },
+    );
+    const payload: Record<string, unknown> = {
+      model: config.model,
+      messages: governed.messages,
+      stream: true,
+      stream_options: { include_usage: true },
+      parallel_tool_calls: false,
+      max_tokens: Math.min(
+        options.maxTokens ?? config.maxOutputTokens,
+        config.maxOutputTokens,
+        remainingTokens,
+      ),
+      ...config.generation,
+    };
+    if (governed.tools.length) payload.tools = governed.tools;
+    // Qwen's serving template uses either native tools or response_format.
+    // With tools, the authorized schema remains in DSH's governed system prompt
+    // and final output is still validated by the same local JSON Schema gate.
+    if (governed.schema && !governed.tools.length)
+      payload.response_format =
+        config.structuredOutputMode === "json_object"
+          ? { type: "json_object" }
+          : {
+              type: "json_schema",
+              json_schema: {
+                name: "operation_result",
+                strict: true,
+                schema: governed.schema,
+              },
+            };
+    const inputTokens = await admitProviderContext(
+      config,
+      payload,
+      options.signal,
+    );
+    if (
+      request.limits.maxInputTokens &&
+      budget.inputTokens + inputTokens > request.limits.maxInputTokens
+    )
+      throw new SafeError("BUDGET_EXCEEDED", "累计输入 token 预算已耗尽");
+    await context.commit(prepared.preparation, governed.messages, payload);
+    return { payload, estimatedInputTokens: inputTokens };
+  } catch (error) {
+    await context.abort(prepared.preparation);
+    throw error;
+  }
+}

package/template/apps/agent-server/runtime/model-plugin.ts

@@ -0,0 +1,308 @@
+import {
+  ToolCallId,
+  type GenerateOptions,
+  type StreamChunk,
+  type ContentBlock,
+} from "@deepseek-ai/dsh-llm";
+import { prepareModelPayload } from "./model-payload.js";
+import { FixedRouteAdapter } from "./model-route.js";
+import { parseUsage } from "./model-usage.js";
+import { SafeError, type RunRequest } from "./contracts.js";
+import type { RuntimeConfig } from "./config.js";
+import { sseJson } from "./governance.js";
+import type { RuntimeStore } from "./store.js";
+
+export interface ExecutionBudget {
+  attempts: number;
+  toolCalls: number;
+  inputTokens: number;
+  outputTokens: number;
+  outputBytes?: number;
+  failure?: SafeError;
+}
+export class GovernedModelAdapter extends FixedRouteAdapter {
+  constructor(
+    config: RuntimeConfig,
+    private readonly request: RunRequest,
+    private readonly runId: string,
+    private readonly store: RuntimeStore,
+    private readonly budget: ExecutionBudget,
+    private readonly images: ReadonlyMap<string, string> = new Map(),
+  ) {
+    super(config);
+  }
+  override async *stream(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    const sequence = this.budget.attempts + 1,
+      started = Date.now();
+    let firstTokenLatencyMs: number | null = null,
+      usage: Record<string, unknown> = {},
+      outcome = "completed";
+    this.store.startAttempt(
+      this.runId,
+      sequence,
+      this.config.deploymentKey,
+      this.config.model,
+    );
+    const signal = AbortSignal.any([
+      ...(options.signal ? [options.signal] : []),
+      AbortSignal.timeout(this.config.requestTimeoutMs),
+    ]);
+    try {
+      for await (const chunk of this.generate({ ...options, signal })) {
+        if (
+          (chunk.type === "text-delta" || chunk.type === "tool-call-delta") &&
+          firstTokenLatencyMs === null
+        )
+          firstTokenLatencyMs = Date.now() - started;
+        if (chunk.type === "usage")
+          usage = {
+            ...chunk.usage,
+            inputTokens:
+              chunk.usage.inputTokens + (chunk.usage.cacheReadTokens ?? 0),
+            cachedInputTokens: chunk.usage.cacheReadTokens ?? null,
+            cacheStatus:
+              chunk.usage.cacheReadTokens === undefined
+                ? "unknown"
+                : chunk.usage.cacheReadTokens > 0
+                  ? "hit"
+                  : "miss",
+            usageSource: "provider-reported",
+          };
+        yield chunk;
+      }
+    } catch (error) {
+      outcome = options.signal?.aborted ? "cancelled" : "failed";
+      this.budget.failure =
+        error instanceof SafeError
+          ? error
+          : new SafeError(
+              "PROVIDER_UNAVAILABLE",
+              "模型服务暂不可用",
+              true,
+              503,
+            );
+      throw this.budget.failure;
+    } finally {
+      this.store.finishAttempt(this.runId, sequence, {
+        outcome,
+        firstTokenLatencyMs,
+        ...usage,
+        safeErrorCode: this.budget.failure?.code ?? null,
+      });
+    }
+  }
+  private async *generate(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    const { config, request, budget } = this;
+    if (
+      ++budget.attempts >
+      Math.min(
+        config.maxAttempts,
+        request.limits.maxModelAttempts ?? config.maxAttempts,
+      )
+    )
+      throw new SafeError("BUDGET_EXCEEDED", "模型调用次数达到上限");
+    if (
+      request.providerEgress.mode !== "configured-endpoint" ||
+      request.providerEgress.deploymentKey !== config.deploymentKey
+    )
+      throw new SafeError("FORBIDDEN", "模型出网未获授权", false, 403);
+    if (
+      request.modelPin &&
+      (request.modelPin.model !== config.model ||
+        request.modelPin.deploymentKey !== config.deploymentKey)
+    )
+      throw new SafeError("MODEL_ROUTE_UNAVAILABLE", "模型路由已发生变化");
+    const remainingTokens =
+      (request.limits.maxOutputTokens ??
+        config.maxOutputTokens * config.maxAttempts) - budget.outputTokens;
+    if (remainingTokens <= 0)
+      throw new SafeError("BUDGET_EXCEEDED", "输出 token 预算已耗尽");
+    const prepared = await prepareModelPayload(
+      config,
+      request,
+      this.runId,
+      this.store,
+      budget,
+      options,
+      this.images,
+      remainingTokens,
+    );
+    const payload = prepared.payload;
+    const response = await fetch(`${config.baseUrl}/chat/completions`, {
+      method: "POST",
+      signal: options.signal,
+      headers: {
+        "content-type": "application/json",
+        ...(config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {}),
+        "X-DSH-Session-Id": this.runId,
+      },
+      body: JSON.stringify(payload),
+      redirect: "error",
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new SafeError(
+        response.status === 429 ? "RATE_LIMITED" : "PROVIDER_UNAVAILABLE",
+        "模型服务请求失败",
+        response.status === 429 || response.status >= 500,
+        503,
+      );
+    }
+    const blocks = new Map<
+      number,
+      {
+        index: number;
+        type: "text" | "reasoning" | "tool-call";
+        text: string;
+        id: string;
+        name: string;
+      }
+    >();
+    let finish = "",
+      usageSeen = false,
+      outputBytes = 0;
+    const blockFor = (
+      key: number,
+      type: "text" | "reasoning" | "tool-call",
+    ) => {
+      let block = blocks.get(key);
+      if (!block) {
+        block = { index: blocks.size, type, text: "", id: "", name: "" };
+        blocks.set(key, block);
+        return { block, fresh: true };
+      }
+      return { block, fresh: false };
+    };
+    for await (const chunk of sseJson(
+      response,
+      Math.min(config.maxResponseBytes, request.limits.maxOutputBytes * 4),
+      options.signal,
+    )) {
+      const usage = chunk.usage as Record<string, unknown> | undefined;
+      if (
+        usage &&
+        Number.isSafeInteger(usage.prompt_tokens) &&
+        Number.isSafeInteger(usage.completion_tokens)
+      ) {
+        const inputTokens = Number(usage.prompt_tokens),
+          outputTokens = Number(usage.completion_tokens);
+        if (inputTokens < 0 || outputTokens < 0 || usageSeen)
+          throw new SafeError("PROVIDER_UNAVAILABLE", "模型计量无效");
+        budget.inputTokens += inputTokens;
+        budget.outputTokens += outputTokens;
+        usageSeen = true;
+        const value = parseUsage(usage);
+        this.store.event(this.runId, "usage.reported", {
+          attemptSequence: budget.attempts,
+          usage: value.canonical,
+        });
+        yield { type: "usage", usage: value.dsh };
+      }
+      const choices = chunk.choices;
+      if (!Array.isArray(choices) || !choices.length) continue;
+      const choice = choices[0] as Record<string, unknown>;
+      if (typeof choice.finish_reason === "string")
+        finish = choice.finish_reason;
+      const delta = choice.delta as Record<string, unknown> | undefined;
+      if (!delta) continue;
+      for (const [field, key, type] of [
+        ["content", -1, "text"],
+        ["reasoning_content", -2, "reasoning"],
+      ] as const) {
+        const text = delta[field];
+        if (typeof text !== "string" || !text) continue;
+        outputBytes += Buffer.byteLength(text);
+        budget.outputBytes =
+          (budget.outputBytes ?? 0) + Buffer.byteLength(text);
+        if (budget.outputBytes > request.limits.maxOutputBytes)
+          throw new SafeError("BUDGET_EXCEEDED", "模型输出超过上限");
+        const { block, fresh } = blockFor(key, type);
+        if (fresh)
+          yield { type: "block-start", index: block.index, blockType: type };
+        block.text += text;
+        if (type === "text" && request.outputPolicy.visibility !== "internal")
+          this.store.event(this.runId, "output.delta", { text });
+        yield {
+          type: type === "text" ? "text-delta" : "reasoning-delta",
+          index: block.index,
+          text,
+        };
+      }
+      if (Array.isArray(delta.tool_calls))
+        for (const raw of delta.tool_calls) {
+          const call = raw as Record<string, unknown>,
+            fn = call.function as Record<string, unknown> | undefined;
+          if (
+            !Number.isSafeInteger(call.index) ||
+            Number(call.index) < 0 ||
+            Number(call.index) > 63
+          )
+            throw new SafeError("TOOL_DENIED", "模型工具协议无效");
+          const { block, fresh } = blockFor(Number(call.index), "tool-call");
+          if (fresh)
+            yield {
+              type: "block-start",
+              index: block.index,
+              blockType: "tool-call",
+            };
+          if (typeof call.id === "string") block.id += call.id;
+          if (typeof fn?.name === "string") block.name += fn.name;
+          const argumentsDelta =
+            typeof fn?.arguments === "string" ? fn.arguments : "";
+          budget.outputBytes =
+            (budget.outputBytes ?? 0) + Buffer.byteLength(argumentsDelta);
+          if (budget.outputBytes > request.limits.maxOutputBytes)
+            throw new SafeError("BUDGET_EXCEEDED", "工具参数累计超过上限");
+          block.text += argumentsDelta;
+          if (Buffer.byteLength(block.text) > request.limits.maxOutputBytes)
+            throw new SafeError("BUDGET_EXCEEDED", "工具参数超过上限");
+          if (block.id)
+            yield {
+              type: "tool-call-delta",
+              index: block.index,
+              id: ToolCallId(block.id),
+              ...(typeof fn?.name === "string" ? { name: fn.name } : {}),
+              argumentsDelta,
+            };
+        }
+    }
+    if (!finish)
+      throw new SafeError("STREAM_INTERRUPTED", "模型响应意外中断", true);
+    for (const block of blocks.values()) {
+      let value: ContentBlock;
+      if (block.type === "tool-call") {
+        if (!block.id || !block.name)
+          throw new SafeError("TOOL_DENIED", "模型工具协议无效");
+        value = {
+          type: "tool-call",
+          id: ToolCallId(block.id),
+          name: block.name,
+          arguments: block.text,
+        };
+      } else value = { type: block.type, text: block.text };
+      yield { type: "block-end", index: block.index, block: value };
+    }
+    if (!usageSeen) {
+      budget.inputTokens += prepared.estimatedInputTokens;
+      budget.outputTokens += outputBytes;
+    }
+    if (
+      (request.limits.maxInputTokens &&
+        budget.inputTokens > request.limits.maxInputTokens) ||
+      (request.limits.maxOutputTokens &&
+        budget.outputTokens > request.limits.maxOutputTokens)
+    )
+      throw new SafeError("BUDGET_EXCEEDED", "模型 token 预算已耗尽");
+    if (finish === "length")
+      throw new SafeError("OUTPUT_TRUNCATED", "模型输出达到长度上限");
+    yield {
+      type: "finish",
+      reason:
+        finish === "tool_calls" ? { kind: "tool-calls" } : { kind: "stop" },
+    };
+  }
+}

package/template/apps/agent-server/runtime/model-route.ts

@@ -0,0 +1,34 @@
+import { LlmAdapter } from "@deepseek-ai/dsh-llm";
+import type { RuntimeConfig } from "./config.js";
+export abstract class FixedRouteAdapter extends LlmAdapter {
+  constructor(protected readonly config: RuntimeConfig) {
+    super();
+  }
+  override providerInfo(provider: string) {
+    return { id: provider, name: "Windy模型服务" };
+  }
+  override async listModels(provider: string) {
+    return [
+      {
+        provider,
+        id: this.config.model,
+        name: this.config.model,
+        inputModalities: this.config.inputModalities.includes("image")
+          ? ["text" as const, "image" as const]
+          : ["text" as const],
+      },
+    ];
+  }
+  override async resolveModel(provider: string, model: string) {
+    return {
+      provider,
+      id: model,
+      name: model,
+      inputModalities: this.config.inputModalities.includes("image")
+        ? ["text" as const, "image" as const]
+        : ["text" as const],
+      context: { contextWindow: this.config.contextWindow },
+      defaultMaxTokens: this.config.maxOutputTokens,
+    };
+  }
+}

package/template/apps/agent-server/runtime/model-usage.ts

@@ -0,0 +1,51 @@
+import type { TokenUsage } from "@deepseek-ai/dsh-llm";
+import { SafeError } from "./contracts.js";
+export function parseUsage(usage: Record<string, unknown>) {
+  const inputTokens = Number(usage.prompt_tokens),
+    outputTokens = Number(usage.completion_tokens);
+  if (
+    ![inputTokens, outputTokens].every(
+      (value) => Number.isSafeInteger(value) && value >= 0,
+    )
+  )
+    throw new SafeError("PROVIDER_UNAVAILABLE", "模型计量无效");
+  const details = usage.prompt_tokens_details as
+    | Record<string, unknown>
+    | undefined;
+  const completion = usage.completion_tokens_details as
+    | Record<string, unknown>
+    | undefined;
+  const rawCached = details?.cached_tokens ?? usage.prompt_cache_hit_tokens,
+    rawReasoning = completion?.reasoning_tokens;
+  const cached =
+    typeof rawCached === "number" &&
+    Number.isSafeInteger(rawCached) &&
+    rawCached >= 0 &&
+    rawCached <= inputTokens
+      ? rawCached
+      : undefined;
+  const reasoning =
+    typeof rawReasoning === "number" &&
+    Number.isSafeInteger(rawReasoning) &&
+    rawReasoning >= 0 &&
+    rawReasoning <= outputTokens
+      ? rawReasoning
+      : undefined;
+  const canonical = {
+    source: "provider-reported",
+    cacheStatus: cached === undefined ? "unknown" : cached > 0 ? "hit" : "miss",
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    ...(cached === undefined ? {} : { cachedInputTokens: cached }),
+    ...(reasoning === undefined ? {} : { reasoningTokens: reasoning }),
+  };
+  const dsh: TokenUsage = {
+    inputTokens: inputTokens - (cached ?? 0),
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    ...(cached === undefined ? {} : { cacheReadTokens: cached }),
+    ...(reasoning === undefined ? {} : { reasoningTokens: reasoning }),
+  };
+  return { canonical, dsh };
+}

package/template/apps/agent-server/runtime/model-wire.ts

@@ -0,0 +1,45 @@
+import type { RequestMessage } from "@deepseek-ai/dsh-llm";
+import { SafeError } from "./contracts.js";
+export function wireMessage(
+  message: RequestMessage,
+  images: ReadonlyMap<string, string> = new Map(),
+): Record<string, unknown> {
+  const text = message.content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("\n");
+  if (message.content.some((block) => block.type === "file"))
+    throw new SafeError(
+      "INVALID_INPUT",
+      "此模型调用不支持直接附件，请使用文件工具",
+    );
+  const result: Record<string, unknown> = {
+    role: message.role === "developer" ? "system" : message.role,
+    content: text,
+  };
+  const imageBlocks = message.content.filter((block) => block.type === "image");
+  if (imageBlocks.length)
+    result.content = [
+      { type: "text", text },
+      ...imageBlocks.map((block) => {
+        const dataUrl = images.get(block.attachment.attachmentId);
+        if (!dataUrl)
+          throw new SafeError("INVALID_INPUT", "图片引用不属于当前任务");
+        return {
+          type: "image_url",
+          image_url: { url: dataUrl, detail: "auto" },
+        };
+      }),
+    ];
+  if (message.role === "tool") result.tool_call_id = message.toolCallId;
+  if (message.role === "assistant") {
+    const calls = message.content.filter((block) => block.type === "tool-call");
+    if (calls.length)
+      result.tool_calls = calls.map((block) => ({
+        id: block.id,
+        type: "function",
+        function: { name: block.name, arguments: block.arguments },
+      }));
+  }
+  return result;
+}

package/template/apps/agent-server/runtime/native-authorization.nodecheck.ts

@@ -0,0 +1,126 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { EventEmitter, once } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import WebSocket, { WebSocketServer } from "ws";
+import { WorkbenchManager, type NativeWorker } from "../native/manager.js";
+import { actorKey } from "../native/config.js";
+import { attachWorkbenchSockets } from "../native/socket.js";
+import { WorkbenchAuthorizationUnavailable } from "../native/authorization.js";
+
+test(
+  "live sockets close on unavailable admission, recover on the same worker, and revoke definitively",
+  { timeout: 10000 },
+  async () => {
+    const home = await mkdtemp(join(tmpdir(), "windy-socket-auth-"));
+    const upstream = createServer();
+    const upstreamWs = new WebSocketServer({ server: upstream });
+    upstreamWs.on("connection", (socket) =>
+      socket.on("message", (data) => socket.send(data)),
+    );
+    upstream.listen(0, "127.0.0.1");
+    await once(upstream, "listening");
+    const port = (upstream.address() as { port: number }).port;
+    let mode: "allowed" | "unavailable" | "denied" = "allowed";
+    const manager = new WorkbenchManager({
+      gateOrigin: "http://fixture",
+      authorize: async () => {
+        if (mode === "unavailable")
+          throw new WorkbenchAuthorizationUnavailable("upstream_status", 503);
+        return mode === "allowed";
+      },
+    });
+    const authority = {
+      actorId: "socket-fixture",
+      session: "s".repeat(43),
+      publicOrigin: "http://localhost:18746",
+    };
+    const worker: NativeWorker = {
+      uid: 20000,
+      key: actorKey(authority.actorId),
+      authority,
+      token: "t".repeat(43),
+      cookie: "fixture=1",
+      port,
+      home,
+      child: Object.assign(new EventEmitter(), {
+        exitCode: 0,
+        signalCode: null,
+      }) as ChildProcess,
+      controller: new AbortController(),
+      admissionController: new AbortController(),
+    };
+    manager.workers.set(worker.key, worker);
+    const server = createServer();
+    const detach = attachWorkbenchSockets(server, manager, () => true);
+    server.listen(0, "127.0.0.1");
+    await once(server, "listening");
+    const proxyPort = (server.address() as { port: number }).port;
+    const clients: WebSocket[] = [];
+    const connect = () => {
+      const client = new WebSocket(
+        `ws://127.0.0.1:${proxyPort}/internal/workbench/api/remote.mux`,
+        {
+          headers: {
+            "x-windy-actor-id": authority.actorId,
+            "x-windy-product-session": authority.session,
+            "x-windy-public-origin": authority.publicOrigin,
+          },
+        },
+      );
+      client.on("error", () => {});
+      clients.push(client);
+      return client;
+    };
+    try {
+      const first = connect();
+      await once(first, "open");
+      const echoed = once(first, "message");
+      first.send("synthetic-ping");
+      assert.equal(String((await echoed)[0]), "synthetic-ping");
+      const firstClosed = once(first, "close");
+      mode = "unavailable";
+      await manager.inspect(worker);
+      await firstClosed;
+      assert.equal(worker.controller.signal.aborted, false);
+      assert.equal(manager.workers.get(worker.key), worker);
+      const rejected = connect();
+      const status = await new Promise<number>((resolve) =>
+        rejected.once("unexpected-response", (_, response) => {
+          response.resume();
+          resolve(response.statusCode!);
+          rejected.terminate();
+        }),
+      );
+      assert.equal(status, 503);
+      mode = "allowed";
+      const recovered = connect();
+      await once(recovered, "open");
+      assert.equal(manager.workers.get(worker.key), worker);
+      const recoveredEcho = once(recovered, "message");
+      recovered.send("recovered");
+      assert.equal(String((await recoveredEcho)[0]), "recovered");
+      const revoked = once(recovered, "close");
+      mode = "denied";
+      await manager.inspect(worker);
+      await revoked;
+      assert.equal(worker.controller.signal.aborted, true);
+      assert.equal(manager.workers.size, 0);
+    } finally {
+      for (const client of clients) client.terminate();
+      detach();
+      for (const client of upstreamWs.clients) client.terminate();
+      upstreamWs.close();
+      await Promise.all([
+        new Promise<void>((resolve) => server.close(() => resolve())),
+        new Promise<void>((resolve) => upstream.close(() => resolve())),
+      ]);
+      await manager.close();
+      await rm(home, { recursive: true, force: true });
+    }
+  },
+);