paseo-plugin-zcode-provider 0.0.0-stage → 0.1.0

package/server/vendor/zcode/packages/model-option-map/src/evaluator.ts

@@ -0,0 +1,214 @@
+import type { RestrictedCelExpression } from "./parser.js";
+import {
+  RestrictedCelError,
+  type JsonObject,
+  type JsonValue,
+  type RestrictedCelValue,
+} from "./types.js";
+
+export function evaluateRestrictedCel(
+  expression: RestrictedCelExpression,
+  input: RestrictedCelValue,
+): JsonValue {
+  assertRestrictedCelValue(input, expression.offset);
+  return freezeJson(evaluate(expression, input));
+}
+
+function evaluate(expression: RestrictedCelExpression, input: RestrictedCelValue): JsonValue {
+  switch (expression.type) {
+    case "literal":
+      return expression.value;
+    case "input":
+      return input;
+    case "array":
+      return expression.elements.map((element) => evaluate(element, input));
+    case "object": {
+      const result: Record<string, JsonValue> = Object.create(null) as Record<string, JsonValue>;
+      for (const entry of expression.entries) {
+        Object.defineProperty(result, entry.key, {
+          configurable: true,
+          enumerable: true,
+          value: evaluate(entry.value, input),
+          writable: true,
+        });
+      }
+      return result;
+    }
+    case "unary":
+      return evaluateUnary(
+        expression.operator,
+        evaluate(expression.operand, input),
+        expression.offset,
+      );
+    case "binary":
+      return evaluateBinary(expression, input);
+    case "conditional":
+      return requireBoolean(evaluate(expression.condition, input), expression.condition.offset)
+        ? evaluate(expression.whenTrue, input)
+        : evaluate(expression.whenFalse, input);
+  }
+}
+
+function evaluateUnary(operator: string, operand: JsonValue, offset: number): JsonValue {
+  if (operator === "!") return !requireBoolean(operand, offset);
+  const number = requireNumber(operand, offset);
+  return assertNumber(operator === "-" ? -number : number, offset);
+}
+
+function evaluateBinary(
+  expression: Extract<RestrictedCelExpression, { type: "binary" }>,
+  input: RestrictedCelValue,
+): JsonValue {
+  const left = evaluate(expression.left, input);
+  if (expression.operator === "&&") {
+    return requireBoolean(left, expression.left.offset)
+      ? requireBoolean(evaluate(expression.right, input), expression.right.offset)
+      : false;
+  }
+  if (expression.operator === "||") {
+    return requireBoolean(left, expression.left.offset)
+      ? true
+      : requireBoolean(evaluate(expression.right, input), expression.right.offset);
+  }
+
+  const right = evaluate(expression.right, input);
+  switch (expression.operator) {
+    case "==":
+      return jsonEquals(left, right);
+    case "!=":
+      return !jsonEquals(left, right);
+    case "+":
+      if (typeof left === "string" && typeof right === "string") return left + right;
+      return assertNumber(
+        requireNumber(left, expression.left.offset) + requireNumber(right, expression.right.offset),
+        expression.offset,
+      );
+    case "-":
+      return numericBinary(left, right, expression, (a, b) => a - b);
+    case "*":
+      return numericBinary(left, right, expression, (a, b) => a * b);
+    case "/":
+      return numericBinary(left, right, expression, (a, b) => a / b);
+    case "%":
+      return numericBinary(left, right, expression, (a, b) => a % b);
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return compare(left, right, expression.operator, expression.offset);
+    default:
+      throw new RestrictedCelError(
+        `unsupported operator ${expression.operator}`,
+        expression.offset,
+      );
+  }
+}
+
+function numericBinary(
+  left: JsonValue,
+  right: JsonValue,
+  expression: Extract<RestrictedCelExpression, { type: "binary" }>,
+  operation: (left: number, right: number) => number,
+): number {
+  return assertNumber(
+    operation(
+      requireNumber(left, expression.left.offset),
+      requireNumber(right, expression.right.offset),
+    ),
+    expression.offset,
+  );
+}
+
+function compare(left: JsonValue, right: JsonValue, operator: string, offset: number): boolean {
+  if (typeof left !== typeof right || (typeof left !== "number" && typeof left !== "string")) {
+    throw new RestrictedCelError(
+      "comparison operands must have the same numeric or string type",
+      offset,
+    );
+  }
+  const comparison =
+    typeof left === "number" && typeof right === "number"
+      ? left < right
+        ? -1
+        : left > right
+          ? 1
+          : 0
+      : String(left) < String(right)
+        ? -1
+        : String(left) > String(right)
+          ? 1
+          : 0;
+  if (operator === "<") return comparison < 0;
+  if (operator === "<=") return comparison <= 0;
+  if (operator === ">") return comparison > 0;
+  return comparison >= 0;
+}
+
+function requireBoolean(value: JsonValue, offset: number): boolean {
+  if (typeof value !== "boolean") {
+    throw new RestrictedCelError("boolean operand required", offset);
+  }
+  return value;
+}
+
+function requireNumber(value: JsonValue, offset: number): number {
+  if (typeof value !== "number") {
+    throw new RestrictedCelError("numeric operand required", offset);
+  }
+  return value;
+}
+
+function assertNumber(value: number, offset: number): number {
+  if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+    throw new RestrictedCelError("numeric result is not JSON-safe", offset);
+  }
+  return value;
+}
+
+function assertRestrictedCelValue(
+  value: unknown,
+  offset: number,
+): asserts value is RestrictedCelValue {
+  if (typeof value === "string") return;
+  if (typeof value === "number") {
+    assertNumber(value, offset);
+    return;
+  }
+  throw new RestrictedCelError("input value must be a string or number", offset);
+}
+
+function jsonEquals(left: JsonValue, right: JsonValue): boolean {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return (
+      Array.isArray(left) &&
+      Array.isArray(right) &&
+      left.length === right.length &&
+      left.every((entry, index) => jsonEquals(entry, right[index]!))
+    );
+  }
+  if (isJsonObject(left) && isJsonObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return (
+      leftKeys.length === rightKeys.length &&
+      leftKeys.every((key) => Object.hasOwn(right, key) && jsonEquals(left[key]!, right[key]!))
+    );
+  }
+  return false;
+}
+
+function freezeJson<T extends JsonValue>(value: T): T {
+  if (Array.isArray(value)) {
+    for (const entry of value) freezeJson(entry);
+  } else if (isJsonObject(value)) {
+    for (const entry of Object.values(value)) freezeJson(entry);
+  } else {
+    return value;
+  }
+  return Object.freeze(value);
+}
+
+function isJsonObject(value: JsonValue): value is JsonObject {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/server/vendor/zcode/packages/model-option-map/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./compiler.js";
+export * from "./merge-patch.js";
+export * from "./option-maps.js";
+export * from "./tokenizer.js";
+export * from "./types.js";

package/server/vendor/zcode/packages/model-option-map/src/merge-patch.ts

@@ -0,0 +1,97 @@
+import { ModelOptionMapError, type JsonObject, type JsonValue } from "./types.js";
+
+export interface NamedJsonMergePatch {
+  readonly option: string;
+  readonly patch: JsonObject;
+}
+
+interface OwnedPath {
+  readonly option: string;
+  readonly path: readonly string[];
+}
+
+export function applyOrderedJsonMergePatches(
+  body: JsonObject,
+  patches: readonly NamedJsonMergePatch[],
+): JsonObject {
+  const ownedPaths: OwnedPath[] = [];
+  let result = cloneJson(body) as JsonObject;
+  for (const namedPatch of patches) {
+    const paths = collectWrittenPaths(namedPatch.patch);
+    for (const path of paths) {
+      const conflict = ownedPaths.find((owned) => pathsOverlap(owned.path, path));
+      if (conflict) {
+        throw new ModelOptionMapError(
+          `Model option maps write conflicting JSON path ${formatPath(path)}: ${conflict.option} and ${namedPatch.option}`,
+        );
+      }
+      ownedPaths.push({ option: namedPatch.option, path });
+    }
+    result = mergeObject(result, namedPatch.patch);
+  }
+  return result;
+}
+
+function collectWrittenPaths(
+  patch: JsonObject,
+  prefix: readonly string[] = [],
+): readonly string[][] {
+  const paths: string[][] = [];
+  for (const [key, value] of Object.entries(patch)) {
+    const path = [...prefix, key];
+    if (isJsonObject(value) && Object.keys(value).length > 0) {
+      paths.push(...collectWrittenPaths(value, path));
+    } else {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+
+function pathsOverlap(left: readonly string[], right: readonly string[]): boolean {
+  const sharedLength = Math.min(left.length, right.length);
+  for (let index = 0; index < sharedLength; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+
+function formatPath(path: readonly string[]): string {
+  return path.length === 0 ? "$" : `$.${path.join(".")}`;
+}
+
+function mergeObject(target: JsonObject, patch: JsonObject): JsonObject {
+  const result = cloneJson(target) as Record<string, JsonValue>;
+  for (const [key, patchValue] of Object.entries(patch)) {
+    if (patchValue === null) {
+      delete result[key];
+      continue;
+    }
+    if (isJsonObject(patchValue)) {
+      const targetValue = result[key];
+      result[key] = mergeObject(isJsonObject(targetValue) ? targetValue : {}, patchValue);
+      continue;
+    }
+    result[key] = cloneJson(patchValue);
+  }
+  return result;
+}
+
+function cloneJson(value: JsonValue): JsonValue {
+  if (Array.isArray(value)) return value.map(cloneJson);
+  if (!isJsonObject(value)) return value;
+  const result: Record<string, JsonValue> = Object.create(null) as Record<string, JsonValue>;
+  for (const [key, entry] of Object.entries(value)) {
+    Object.defineProperty(result, key, {
+      configurable: true,
+      enumerable: true,
+      value: cloneJson(entry),
+      writable: true,
+    });
+  }
+  return result;
+}
+
+function isJsonObject(value: JsonValue | undefined): value is JsonObject {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/server/vendor/zcode/packages/model-option-map/src/option-maps.ts

@@ -0,0 +1,42 @@
+import { compileModelOptionMap } from "./compiler.js";
+import { applyOrderedJsonMergePatches, type NamedJsonMergePatch } from "./merge-patch.js";
+import { ModelOptionMapError, type JsonObject, type ModelOptionMapProgram } from "./types.js";
+
+export interface ModelOptionMapSpecs {
+  readonly reasoningLevel: { readonly map: string };
+  readonly maxOutputTokens: { readonly map: string };
+}
+
+export interface ModelOptionValues {
+  readonly reasoningLevel: string;
+  readonly maxOutputTokens: number;
+}
+
+export interface CompiledModelOptionMaps {
+  apply(body: JsonObject, values: ModelOptionValues): JsonObject;
+}
+
+/** Model 创建时编译一次；每个请求只绑定本轮冻结的 Option value。 */
+export function compileModelOptionMaps(specs: ModelOptionMapSpecs): CompiledModelOptionMaps {
+  const reasoningLevel = compileModelOptionMap(specs.reasoningLevel.map, "reasoningLevel");
+  const maxOutputTokens = compileModelOptionMap(specs.maxOutputTokens.map, "maxOutputTokens");
+  return Object.freeze({
+    apply(body: JsonObject, values: ModelOptionValues): JsonObject {
+      const patches: NamedJsonMergePatch[] = [];
+      if (values.reasoningLevel === undefined) {
+        throw new ModelOptionMapError("reasoningLevel requires an effective value");
+      }
+      patches.push(optionPatch("reasoningLevel", reasoningLevel, values.reasoningLevel));
+      patches.push(optionPatch("maxOutputTokens", maxOutputTokens, values.maxOutputTokens));
+      return applyOrderedJsonMergePatches(body, patches);
+    },
+  });
+}
+
+function optionPatch(
+  option: string,
+  program: ModelOptionMapProgram,
+  value: string | number,
+): NamedJsonMergePatch {
+  return { option, patch: program.evaluate(value) };
+}

package/server/vendor/zcode/packages/model-option-map/src/parser.ts

@@ -0,0 +1,240 @@
+import { RestrictedCelError, type ModelOptionName } from "./types.js";
+import type { RestrictedCelToken } from "./tokenizer.js";
+
+export type RestrictedCelExpression =
+  | {
+      readonly type: "literal";
+      readonly value: string | number | boolean | null;
+      readonly offset: number;
+    }
+  | { readonly type: "input"; readonly offset: number }
+  | {
+      readonly type: "array";
+      readonly elements: readonly RestrictedCelExpression[];
+      readonly offset: number;
+    }
+  | {
+      readonly type: "object";
+      readonly entries: readonly {
+        readonly key: string;
+        readonly value: RestrictedCelExpression;
+        readonly offset: number;
+      }[];
+      readonly offset: number;
+    }
+  | {
+      readonly type: "unary";
+      readonly operator: "!" | "-" | "+";
+      readonly operand: RestrictedCelExpression;
+      readonly offset: number;
+    }
+  | {
+      readonly type: "binary";
+      readonly operator: string;
+      readonly left: RestrictedCelExpression;
+      readonly right: RestrictedCelExpression;
+      readonly offset: number;
+    }
+  | {
+      readonly type: "conditional";
+      readonly condition: RestrictedCelExpression;
+      readonly whenTrue: RestrictedCelExpression;
+      readonly whenFalse: RestrictedCelExpression;
+      readonly offset: number;
+    };
+
+export function parseRestrictedCel(
+  tokens: readonly RestrictedCelToken[],
+  variableName: ModelOptionName,
+): RestrictedCelExpression {
+  return new Parser(tokens, variableName).parse();
+}
+
+class Parser {
+  #index = 0;
+
+  constructor(
+    private readonly tokens: readonly RestrictedCelToken[],
+    private readonly variableName: ModelOptionName,
+  ) {}
+
+  parse(): RestrictedCelExpression {
+    const expression = this.parseConditional();
+    const trailing = this.current();
+    if (trailing.kind !== "eof") {
+      if (trailing.value === ".") {
+        throw new RestrictedCelError("member access is not supported", trailing.offset);
+      }
+      if (trailing.value === "(") {
+        throw new RestrictedCelError("function calls are not supported", trailing.offset);
+      }
+      throw new RestrictedCelError(
+        `unexpected token ${JSON.stringify(trailing.value)}`,
+        trailing.offset,
+      );
+    }
+    return expression;
+  }
+
+  private parseConditional(): RestrictedCelExpression {
+    const condition = this.parseLogicalOr();
+    if (!this.consume("?")) return condition;
+    const whenTrue = this.parseConditional();
+    this.expect(":");
+    const whenFalse = this.parseConditional();
+    return { type: "conditional", condition, whenTrue, whenFalse, offset: condition.offset };
+  }
+
+  private parseLogicalOr(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseLogicalAnd(), new Set(["||"]));
+  }
+
+  private parseLogicalAnd(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseEquality(), new Set(["&&"]));
+  }
+
+  private parseEquality(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseRelational(), new Set(["==", "!="]));
+  }
+
+  private parseRelational(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseAdditive(), new Set(["<", "<=", ">", ">="]));
+  }
+
+  private parseAdditive(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseMultiplicative(), new Set(["+", "-"]));
+  }
+
+  private parseMultiplicative(): RestrictedCelExpression {
+    return this.parseBinary(() => this.parseUnary(), new Set(["*", "/", "%"]));
+  }
+
+  private parseBinary(
+    parseOperand: () => RestrictedCelExpression,
+    operators: ReadonlySet<string>,
+  ): RestrictedCelExpression {
+    let expression = parseOperand();
+    while (this.current().kind === "operator" && operators.has(this.current().value)) {
+      const operator = this.advance();
+      expression = {
+        type: "binary",
+        operator: operator.value,
+        left: expression,
+        right: parseOperand(),
+        offset: operator.offset,
+      };
+    }
+    return expression;
+  }
+
+  private parseUnary(): RestrictedCelExpression {
+    const token = this.current();
+    if (
+      token.kind === "operator" &&
+      (token.value === "!" || token.value === "-" || token.value === "+")
+    ) {
+      this.advance();
+      return {
+        type: "unary",
+        operator: token.value,
+        operand: this.parseUnary(),
+        offset: token.offset,
+      };
+    }
+    return this.parsePrimary();
+  }
+
+  private parsePrimary(): RestrictedCelExpression {
+    const token = this.advance();
+    if (token.kind === "number") {
+      const value = Number(token.value);
+      if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+        throw new RestrictedCelError("number literal is not JSON-safe", token.offset);
+      }
+      return { type: "literal", value, offset: token.offset };
+    }
+    if (token.kind === "string")
+      return { type: "literal", value: token.value, offset: token.offset };
+    if (token.kind === "identifier") {
+      if (this.current().value === "(") {
+        throw new RestrictedCelError("function calls are not supported", this.current().offset);
+      }
+      if (token.value === this.variableName) return { type: "input", offset: token.offset };
+      if (token.value === "true" || token.value === "false") {
+        return { type: "literal", value: token.value === "true", offset: token.offset };
+      }
+      if (token.value === "null") return { type: "literal", value: null, offset: token.offset };
+      throw new RestrictedCelError(
+        `unknown identifier ${JSON.stringify(token.value)}`,
+        token.offset,
+      );
+    }
+    if (token.value === "(") {
+      const expression = this.parseConditional();
+      this.expect(")");
+      return expression;
+    }
+    if (token.value === "[") return this.parseArray(token.offset);
+    if (token.value === "{") return this.parseObject(token.offset);
+    throw new RestrictedCelError(`unexpected token ${JSON.stringify(token.value)}`, token.offset);
+  }
+
+  private parseArray(offset: number): RestrictedCelExpression {
+    const elements: RestrictedCelExpression[] = [];
+    if (!this.consume("]")) {
+      do elements.push(this.parseConditional());
+      while (this.consume(","));
+      this.expect("]");
+    }
+    return { type: "array", elements: Object.freeze(elements), offset };
+  }
+
+  private parseObject(offset: number): RestrictedCelExpression {
+    const entries: { key: string; value: RestrictedCelExpression; offset: number }[] = [];
+    const keys = new Set<string>();
+    if (!this.consume("}")) {
+      do {
+        const key = this.advance();
+        if (key.kind !== "string") {
+          throw new RestrictedCelError("object keys must be string literals", key.offset);
+        }
+        if (keys.has(key.value)) {
+          throw new RestrictedCelError(
+            `duplicate object key ${JSON.stringify(key.value)}`,
+            key.offset,
+          );
+        }
+        keys.add(key.value);
+        this.expect(":");
+        entries.push({ key: key.value, value: this.parseConditional(), offset: key.offset });
+      } while (this.consume(","));
+      this.expect("}");
+    }
+    return { type: "object", entries: Object.freeze(entries), offset };
+  }
+
+  private consume(value: string): boolean {
+    if (this.current().value !== value) return false;
+    this.#index += 1;
+    return true;
+  }
+
+  private expect(value: string): RestrictedCelToken {
+    const token = this.current();
+    if (token.value !== value) {
+      throw new RestrictedCelError(`expected ${JSON.stringify(value)}`, token.offset);
+    }
+    this.#index += 1;
+    return token;
+  }
+
+  private advance(): RestrictedCelToken {
+    const token = this.current();
+    if (token.kind !== "eof") this.#index += 1;
+    return token;
+  }
+
+  private current(): RestrictedCelToken {
+    return this.tokens[this.#index] ?? this.tokens[this.tokens.length - 1]!;
+  }
+}