create-windy 0.8.3 → 0.10.0

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

@@ -0,0 +1,246 @@
+import { digest, SafeError } from "./contracts.js";
+import { isIP } from "node:net";
+export interface RuntimeConfig {
+  internalToken: string;
+  baseUrl: string;
+  model: string;
+  structuredOutputMode: "json_schema" | "json_object";
+  deploymentKey: string;
+  apiKey: string;
+  databasePath: string;
+  toolHostUrl: string;
+  concurrency: number;
+  queueDepth: number;
+  contextWindow: number;
+  maxOutputTokens: number;
+  maxResponseBytes: number;
+  maxAttempts: number;
+  internalOutputSecret: string;
+  generation: Record<string, unknown>;
+  capabilities: string[];
+  inputModalities: string[];
+  artifactUrl: string;
+  deploymentIdentity: string;
+  releaseDigest: string;
+  contextHostUrl: string;
+  tokenizePath: string;
+  providerContextTokens?: number;
+  contextSafetyTokens: number;
+  requestTimeoutMs: number;
+  maxDurationSeconds: number;
+  providerAuditRetentionDays: number;
+}
+export function configFromEnvironment(
+  env: NodeJS.ProcessEnv = process.env,
+): RuntimeConfig {
+  function integer(key: string, fallback: number, min: number, max: number) {
+    const value = Number(env[key]?.trim() || fallback);
+    if (!Number.isSafeInteger(value) || value < min || value > max)
+      throw new Error(`${key} is invalid`);
+    return value;
+  }
+  const baseUrl = (env.QWEN_API_URL ?? env.DSH_MODEL_BASE_URL ?? "").replace(
+    /\/$/,
+    "",
+  );
+  if (baseUrl) {
+    const url = new URL(baseUrl);
+    if (
+      !["http:", "https:"].includes(url.protocol) ||
+      url.username ||
+      url.password ||
+      url.search ||
+      url.hash
+    )
+      throw new Error("Invalid model endpoint");
+    if (url.protocol === "http:" && !privateModelHost(url.hostname))
+      throw new Error("Model HTTP host must be private or local");
+    if (
+      url.protocol === "https:" &&
+      !(env.AI_PROVIDER_HTTPS_HOST_ALLOWLIST ?? "")
+        .split(",")
+        .map((v) => v.trim())
+        .includes(url.hostname)
+    )
+      throw new Error("Model HTTPS host is not authorized");
+  }
+  const structuredOutputMode =
+    env.QWEN_STRUCTURED_OUTPUT_MODE?.trim() || "json_schema";
+  if (
+    structuredOutputMode !== "json_schema" &&
+    structuredOutputMode !== "json_object"
+  )
+    throw new Error("QWEN_STRUCTURED_OUTPUT_MODE invalid");
+  const generation: Record<string, unknown> = {};
+  const tokenizePath = env.AI_PROVIDER_TOKENIZE_PATH?.trim() || "";
+  if (
+    tokenizePath &&
+    (!tokenizePath.startsWith("/") ||
+      tokenizePath.startsWith("//") ||
+      /[?#\\\s]/.test(tokenizePath))
+  )
+    throw new Error("AI_PROVIDER_TOKENIZE_PATH invalid");
+  for (const [name, field, min, max] of [
+    ["AI_PROVIDER_TEMPERATURE", "temperature", 0, 2],
+    ["AI_PROVIDER_TOP_P", "top_p", 0, 1],
+    ["AI_PROVIDER_TOP_K", "top_k", 1, 1000],
+    ["AI_PROVIDER_PRESENCE_PENALTY", "presence_penalty", -2, 2],
+  ] as const) {
+    if (env[name]?.trim()) {
+      const value = Number(env[name]);
+      if (
+        !Number.isFinite(value) ||
+        value < min ||
+        value > max ||
+        (field === "top_k" && !Number.isInteger(value))
+      )
+        throw new Error(`${name} invalid`);
+      generation[field] = value;
+    }
+  }
+  const thinkingParameter =
+    env.AI_PROVIDER_THINKING_PARAMETER?.trim() || "top-level";
+  if (!["top-level", "chat-template"].includes(thinkingParameter))
+    throw new Error("AI_PROVIDER_THINKING_PARAMETER invalid");
+  const thinking = env.AI_PROVIDER_ENABLE_THINKING?.trim();
+  if (thinking) {
+    if (!["true", "false", "1", "0"].includes(thinking))
+      throw new Error("AI_PROVIDER_ENABLE_THINKING invalid");
+    const enabled = thinking === "true" || thinking === "1";
+    if (thinkingParameter === "chat-template")
+      generation.chat_template_kwargs = { enable_thinking: enabled };
+    else generation.enable_thinking = enabled;
+  }
+  return {
+    internalToken: env.AGENT_SERVER_INTERNAL_TOKEN ?? "",
+    baseUrl,
+    model: env.QWEN_MODEL ?? env.DSH_MODEL ?? "",
+    structuredOutputMode,
+    deploymentKey: env.AI_PROVIDER_DEPLOYMENT_KEY ?? "ai.openai-compatible",
+    apiKey: env.QWEN_API_KEY ?? "",
+    databasePath:
+      env.AGENT_RUNTIME_DATABASE_PATH ?? "/data/embedded-dsh.sqlite",
+    toolHostUrl: env.AI_TOOL_HOST_URL ?? "http://server:9747",
+    concurrency: integer(
+      "AI_PROVIDER_MAX_CONCURRENT_RUNS",
+      providerCapacityDefault(env),
+      1,
+      64,
+    ),
+    queueDepth: integer("AI_PROVIDER_MAX_QUEUE_DEPTH", 4, 0, 1000),
+    contextWindow: integer("DSH_CONTEXT_WINDOW", 32768, 4096, 1048576),
+    maxOutputTokens: integer("DSH_MAX_OUTPUT_TOKENS", 2048, 128, 32768),
+    maxResponseBytes: integer(
+      "AI_PROVIDER_MAX_RESPONSE_BYTES",
+      2097152,
+      1024,
+      16777216,
+    ),
+    maxAttempts: integer("AI_PROVIDER_MAX_TOOL_ROUNDS", 8, 1, 500),
+    internalOutputSecret: env.AGENT_INTERNAL_OUTPUT_ENCRYPTION_SECRET ?? "",
+    generation,
+    capabilities: (
+      env.AI_PROVIDER_CAPABILITIES ||
+      "text-generation,structured-output,tool-calling"
+    )
+      .split(",")
+      .map((value) => value.trim()),
+    inputModalities: (env.AI_PROVIDER_INPUT_MODALITIES || "text")
+      .split(",")
+      .map((value) => value.trim()),
+    artifactUrl:
+      env.AI_ARTIFACT_URL || "http://server:9747/api/internal/ai/artifacts",
+    deploymentIdentity: env.AI_PROVIDER_DEPLOYMENT_IDENTITY || "",
+    releaseDigest: env.AI_PROVIDER_RELEASE_DIGEST || "",
+    contextHostUrl:
+      env.AGENT_CONTEXT_HOST_URL ||
+      env.AI_TOOL_HOST_URL ||
+      "http://server:9747",
+    tokenizePath,
+    providerContextTokens: env.AI_PROVIDER_CONTEXT_TOKENS?.trim()
+      ? integer("AI_PROVIDER_CONTEXT_TOKENS", 32768, 1, 2147483647)
+      : undefined,
+    contextSafetyTokens: integer(
+      "AI_PROVIDER_CONTEXT_SAFETY_TOKENS",
+      512,
+      0,
+      2147483647,
+    ),
+    requestTimeoutMs: integer(
+      "AI_PROVIDER_REQUEST_TIMEOUT_MS",
+      60000,
+      1000,
+      300000,
+    ),
+    maxDurationSeconds: integer(
+      "AI_PROVIDER_MAX_DURATION_SECONDS",
+      300,
+      1,
+      300,
+    ),
+    providerAuditRetentionDays: integer(
+      "AI_PROVIDER_AUDIT_RETENTION_DAYS",
+      190,
+      1,
+      3650,
+    ),
+  };
+}
+export function providerCapacityDefault(
+  env: NodeJS.ProcessEnv = process.env,
+): number {
+  const profile = env.AI_PROVIDER_CAPACITY_PROFILE?.trim() || "remote";
+  if (profile !== "remote" && profile !== "local")
+    throw new Error("AI_PROVIDER_CAPACITY_PROFILE invalid");
+  return profile === "local" ? 1 : 3;
+}
+function privateModelHost(raw: string): boolean {
+  const host = raw.replace(/^\[|\]$/g, "").toLowerCase();
+  if (
+    host === "localhost" ||
+    host.endsWith(".localhost") ||
+    host.endsWith(".internal") ||
+    (!host.includes(".") && !host.includes(":"))
+  )
+    return true;
+  if (isIP(host) === 4) {
+    const [a, b] = host.split(".").map(Number);
+    return (
+      a === 127 ||
+      a === 10 ||
+      (a === 172 && b! >= 16 && b! <= 31) ||
+      (a === 192 && b === 168) ||
+      (a === 169 && b === 254)
+    );
+  }
+  return (
+    isIP(host) === 6 &&
+    (host === "::1" ||
+      host.startsWith("fc") ||
+      host.startsWith("fd") ||
+      host.startsWith("fe80:"))
+  );
+}
+export function requireModel(config: RuntimeConfig) {
+  if (!config.baseUrl || !config.model)
+    throw new SafeError(
+      "MODEL_ROUTE_UNAVAILABLE",
+      "模型服务尚未配置",
+      true,
+      503,
+    );
+}
+export function modelCoordinate(config: RuntimeConfig) {
+  requireModel(config);
+  return {
+    deploymentKey: config.deploymentKey,
+    model: config.model,
+    modelPolicyDigest: digest({
+      engine: "dsh",
+      deploymentKey: config.deploymentKey,
+      model: config.model,
+      endpointDigest: digest(config.baseUrl),
+      generationParameters: config.generation,
+    }),
+  };
+}

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

@@ -0,0 +1,70 @@
+import type { RuntimeConfig } from "./config.js";
+import { SafeError } from "./contracts.js";
+import { boundedBody } from "./tool-plugin.js";
+/** Measures the exact governed serving template when a tokenizer is configured. */
+export async function admitProviderContext(
+  config: RuntimeConfig,
+  payload: Record<string, unknown>,
+  signal?: AbortSignal,
+): Promise<number> {
+  const body = JSON.stringify(payload);
+  let inputTokens = Buffer.byteLength(body);
+  // DSH's window is profile metadata, not an attested serving capacity.
+  // Preserve the existing opt-in hard guard; still return the conservative
+  // estimate so a Run's explicit cumulative input budget remains enforced.
+  if (config.providerContextTokens === undefined) return inputTokens;
+  if (config.tokenizePath) {
+    const endpoint = new URL(
+      config.tokenizePath,
+      new URL(config.baseUrl).origin,
+    );
+    const response = await fetch(endpoint, {
+      method: "POST",
+      signal: signal
+        ? AbortSignal.any([signal, AbortSignal.timeout(10000)])
+        : AbortSignal.timeout(10000),
+      redirect: "error",
+      headers: {
+        "content-type": "application/json",
+        ...(config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {}),
+      },
+      body,
+    });
+    if ([404, 405, 501].includes(response.status))
+      await response.body?.cancel();
+    else {
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new SafeError(
+          "PROVIDER_UNAVAILABLE",
+          "模型 Token 预检失败",
+          true,
+        );
+      }
+      const value = JSON.parse(
+          await boundedBody(response, config.maxResponseBytes),
+        ) as Record<string, unknown>,
+        count = value.count ?? value.prompt_tokens;
+      if (
+        typeof count !== "number" ||
+        !Number.isSafeInteger(count) ||
+        count < 0
+      )
+        throw new SafeError(
+          "PROVIDER_UNAVAILABLE",
+          "模型 Token 预检返回协议无效",
+        );
+      inputTokens = count;
+    }
+  }
+  const outputTokens = Number(payload.max_tokens ?? config.maxOutputTokens);
+  if (
+    inputTokens + outputTokens + config.contextSafetyTokens >
+    config.providerContextTokens
+  )
+    throw new SafeError(
+      "CONTEXT_LIMIT",
+      "模型输入、输出预留及安全余量超过上下文容量",
+    );
+  return inputTokens;
+}

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

@@ -0,0 +1,306 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import type { RuntimeConfig } from "./config.js";
+import { SafeError, type RunRequest } from "./contracts.js";
+import { boundedBody } from "./tool-plugin.js";
+const reference = z.object({
+  moduleKey: z.string().min(1),
+  kind: z.string().min(1),
+  id: z.string().min(1),
+  version: z.string().min(1),
+  sequence: z.number().int().positive(),
+  digest: z.string().regex(/^[a-f0-9]{64}$/),
+  validity: z.object({
+    status: z.string(),
+    checkedAt: z.string(),
+    expiresAt: z.string().nullish(),
+    reason: z.string().nullish(),
+  }),
+});
+const preparationSchema = z.object({
+  preparationId: z.string().min(1).max(160),
+  sources: z
+    .array(
+      z.object({
+        reference,
+        content: z.unknown(),
+        role: z.enum(["system", "user", "assistant", "tool"]).default("system"),
+      }),
+    )
+    .min(1)
+    .max(128),
+});
+export type ContextPreparation = z.infer<typeof preparationSchema> & {
+  insertionStart: number;
+};
+export function canonicalDigest(value: unknown): string {
+  function sorted(item: unknown): unknown {
+    if (Array.isArray(item)) return item.map(sorted);
+    if (item && typeof item === "object")
+      return Object.fromEntries(
+        Object.entries(item)
+          .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+          .map(([key, entry]) => [key, sorted(entry)]),
+      );
+    return item;
+  }
+  return createHash("sha256")
+    .update(JSON.stringify(sorted(value)))
+    .digest("hex");
+}
+const unavailable = () =>
+  new SafeError(
+    "RUNTIME_UNAVAILABLE",
+    "长期 Session Context 暂不可用",
+    true,
+    503,
+  );
+export class HostContextPlugin {
+  constructor(
+    private config: RuntimeConfig,
+    private request: RunRequest,
+    private runId: string,
+    private attemptId: string,
+    private signal: AbortSignal | undefined,
+  ) {}
+  async prepare(messages: Record<string, unknown>[]): Promise<{
+    messages: Record<string, unknown>[];
+    preparation?: ContextPreparation;
+  }> {
+    const binding = this.request.longSession;
+    if (!binding) return { messages };
+    if (!this.request.executionGrant) throw unavailable();
+    const body = preparationSchema.parse(await this.post("prepare"));
+    const returned = body.sources.map(
+      (source) =>
+        `${source.reference.moduleKey}\0${source.reference.kind}\0${source.reference.id}`,
+    );
+    const coordinates = body.sources.map(
+      (source) =>
+        `${source.reference.moduleKey}\0${source.reference.kind}\0${source.reference.id}\0${source.reference.version}\0${source.reference.sequence}`,
+    );
+    if (
+      binding.sources.some(
+        (source) =>
+          !returned.includes(
+            `${source.moduleKey}\0${source.kind}\0${source.id}`,
+          ),
+      ) ||
+      new Set(coordinates).size !== coordinates.length
+    )
+      throw unavailable();
+    for (const source of body.sources) {
+      const validity = source.reference.validity;
+      if (
+        validity.status !== "valid" ||
+        !Number.isFinite(Date.parse(validity.checkedAt)) ||
+        (validity.expiresAt &&
+          (!Number.isFinite(Date.parse(validity.expiresAt)) ||
+            Date.parse(validity.expiresAt) <= Date.now())) ||
+        canonicalDigest({ role: source.role, content: source.content }) !==
+          source.reference.digest
+      )
+        throw unavailable();
+    }
+    const insertionStart = messages[0]?.role === "system" ? 1 : 0;
+    return {
+      preparation: { ...body, insertionStart },
+      messages: [
+        ...messages.slice(0, insertionStart),
+        ...body.sources.map((source) => ({
+          role: source.role,
+          content: source.content,
+        })),
+        ...messages.slice(insertionStart),
+      ],
+    };
+  }
+  async commit(
+    preparation: ContextPreparation | undefined,
+    messages: Record<string, unknown>[],
+    payload: Record<string, unknown>,
+  ) {
+    if (!this.request.longSession) return;
+    if (!preparation) throw unavailable();
+    const raw = JSON.stringify(payload),
+      requestDigest = createHash("sha256").update(raw).digest("hex");
+    const imageReferences = new Map<
+      string,
+      { sha256: string; mediaType: string; byteSize: number }
+    >();
+    for (const message of messages)
+      if (Array.isArray(message.content))
+        for (const rawPart of message.content) {
+          const part = rawPart as Record<string, unknown>,
+            image = part.image_url as { url?: string } | undefined;
+          if (part.type === "image_url" && typeof image?.url === "string") {
+            const encoded = image.url.split(",")[1];
+            if (!encoded) throw unavailable();
+            const bytes = Buffer.from(encoded, "base64");
+            imageReferences.set(image.url, {
+              sha256: createHash("sha256").update(bytes).digest("hex"),
+              mediaType: "image/png",
+              byteSize: bytes.length,
+            });
+          }
+        }
+    const governedEnvelope = {
+      provider: {
+        deploymentKey: this.config.deploymentKey,
+        model: this.config.model,
+        requestDigest,
+        toolsDigest: canonicalDigest(payload.tools ?? null),
+        outputSchemaDigest: canonicalDigest(payload.response_format ?? null),
+      },
+      messages: messages.map((message, ordinal) => {
+        const content = Array.isArray(message.content)
+          ? message.content.map((rawPart) => {
+              const part = rawPart as Record<string, unknown>;
+              if (part.type === "text") return part;
+              const image = part.image_url as { url: string },
+                artifact = imageReferences.get(image.url);
+              if (!artifact) throw unavailable();
+              return { type: "artifact_ref", ...artifact };
+            })
+          : message.content;
+        const digest = canonicalDigest(message),
+          role = String(message.role),
+          sourceIndex = ordinal - preparation.insertionStart;
+        let origins: Record<string, unknown>[];
+        if (sourceIndex >= 0 && sourceIndex < preparation.sources.length) {
+          const source = preparation.sources[sourceIndex]!.reference;
+          origins = [
+            {
+              type: "context-source",
+              sourceId: source.id,
+              sourceVersion: source.version,
+              digest: source.digest,
+              source,
+            },
+          ];
+        } else if (ordinal === 0 && role === "system")
+          origins = [
+            {
+              type: "instructions",
+              sourceId: `${this.runId}:instructions`,
+              sourceVersion: String(
+                this.request.release.promptVersion ?? "dsh",
+              ),
+              digest,
+            },
+          ];
+        else if (role === "user")
+          origins = [
+            {
+              type: "user-prompt",
+              sourceId: `${this.runId}:user-prompt`,
+              sourceVersion: this.runId,
+              digest,
+            },
+            ...[...imageReferences.values()].map((artifact) => ({
+              type: "artifact",
+              sourceId: artifact.sha256,
+              sourceVersion: artifact.sha256,
+              digest: artifact.sha256,
+            })),
+          ];
+        else if (role === "assistant")
+          origins = [
+            {
+              type: "provider-output",
+              sourceId: `${this.runId}:message:${ordinal}`,
+              sourceVersion: this.attemptId,
+              digest,
+            },
+          ];
+        else if (role === "tool" && typeof message.tool_call_id === "string")
+          origins = [
+            {
+              type: "tool-receipt",
+              sourceId: message.tool_call_id,
+              sourceVersion: this.attemptId,
+              digest,
+            },
+          ];
+        else throw unavailable();
+        return {
+          ordinal,
+          role,
+          content,
+          digest,
+          recoveryDigest: canonicalDigest({ role, content }),
+          origins,
+        };
+      }),
+    };
+    const value = z
+      .object({
+        contextVersionId: z.string().min(1),
+        digest: z.string().regex(/^[a-f0-9]{64}$/),
+        status: z.literal("active"),
+        providerRequestDigest: z.literal(requestDigest),
+      })
+      .parse(
+        await this.post("commit", {
+          preparationId: preparation.preparationId,
+          governedEnvelope,
+        }),
+      );
+    return { contextVersionId: value.contextVersionId, digest: value.digest };
+  }
+  async abort(preparation: ContextPreparation | undefined) {
+    if (preparation)
+      await this.post("abort", {
+        preparationId: preparation.preparationId,
+      }).catch(() => undefined);
+  }
+  private async post(
+    phase: "prepare" | "commit" | "abort",
+    fields: Record<string, unknown> = {},
+  ): Promise<unknown> {
+    const binding = this.request.longSession;
+    if (!binding) throw unavailable();
+    const endpoint = new URL(this.config.contextHostUrl),
+      allowed = new URL(this.config.toolHostUrl);
+    if (
+      endpoint.origin !== allowed.origin ||
+      endpoint.username ||
+      endpoint.password ||
+      endpoint.search ||
+      endpoint.hash
+    )
+      throw unavailable();
+    try {
+      const response = await fetch(
+        `${endpoint.href.replace(/\/$/, "")}/api/internal/agent/context-versions`,
+        {
+          method: "POST",
+          signal: this.signal
+            ? AbortSignal.any([this.signal, AbortSignal.timeout(10000)])
+            : AbortSignal.timeout(10000),
+          redirect: "error",
+          headers: {
+            authorization: `Bearer ${this.config.internalToken}`,
+            "content-type": "application/json",
+          },
+          body: JSON.stringify({
+            ...binding,
+            runId: this.runId,
+            modelAttemptId: this.attemptId,
+            authorizationGrant: this.request.executionGrant,
+            contractVersion: 2,
+            phase,
+            ...fields,
+          }),
+        },
+      );
+      if (response.status !== 200) {
+        await response.body?.cancel();
+        throw unavailable();
+      }
+      return JSON.parse(await boundedBody(response, 2097152));
+    } catch {
+      throw unavailable();
+    }
+  }
+}