agentv 5.3.1-next.1 → 5.3.2-next.1

package/dist/chunk-MMDLXYBX.js

@@ -0,0 +1,721 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  PromptTemplateInputSchema,
+  ScriptGraderInputSchema,
+  ScriptGraderResultSchema,
+  runScriptGrader
+} from "./chunk-AQ5BIAXF.js";
+import {
+  toCamelCaseDeep
+} from "./chunk-6262OKXM.js";
+
+// ../../packages/sdk/dist/index.js
+import { stringify as stringifyYaml } from "yaml";
+import { readFile, stat } from "node:fs/promises";
+import nodePath from "node:path";
+import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
+var EVAL_SUITE_SYMBOL = Symbol.for("agentv/eval-suite");
+var TO_EVAL_YAML_OBJECT_SYMBOL = Symbol.for("agentv/to-eval-yaml-object");
+var KNOWN_SNAKE_CASE_KEYS = {
+  afterAll: "after_all",
+  afterEach: "after_each",
+  argsMatch: "args_match",
+  beforeAll: "before_all",
+  beforeEach: "before_each",
+  budgetUsd: "budget_usd",
+  conversationId: "conversation_id",
+  dependsOn: "depends_on",
+  expectedOutput: "expected_output",
+  explorationTolerance: "exploration_tolerance",
+  failOnError: "fail_on_error",
+  inputFiles: "input_files",
+  keepWorkspaces: "keep_workspaces",
+  maxCalls: "max_calls",
+  maxCostUsd: "max_cost_usd",
+  maxDurationMs: "max_duration_ms",
+  maxInput: "max_input",
+  maxLlmCalls: "max_llm_calls",
+  maxOutput: "max_output",
+  maxSteps: "max_steps",
+  maxTokens: "max_tokens",
+  maxToolCalls: "max_tool_calls",
+  minScore: "min_score",
+  onDependencyFailure: "on_dependency_failure",
+  onTurnFailure: "on_turn_failure",
+  outputPath: "output_path",
+  readOnly: "read_only",
+  reasoningEffort: "reasoning_effort",
+  rubricPrompt: "rubric_prompt",
+  scoreRange: "score_range",
+  scoreRanges: "score_ranges",
+  skipDefaults: "skip_defaults",
+  targetExplorationRatio: "target_exploration_ratio",
+  timeoutMs: "timeout_ms",
+  timeoutSeconds: "timeout_seconds",
+  useTarget: "use_target",
+  defaultTest: "default_test",
+  windowSize: "window_size"
+};
+function lowerEvalYamlValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => lowerEvalYamlValue(item));
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      const loweredKey = KNOWN_SNAKE_CASE_KEYS[key] ?? key;
+      result[loweredKey] = lowerEvalYamlValue(nestedValue);
+    }
+    return result;
+  }
+  return value;
+}
+function lowerEvalConfig(config) {
+  const lowered = lowerEvalYamlValue(config);
+  const { budget_usd: budgetUsd, repeat, ...loweredWithoutRuntimeOptions } = lowered;
+  validateRepeatValue(repeat, "repeat");
+  if (budgetUsd === void 0 && repeat === void 0) {
+    return lowered;
+  }
+  const evaluateOptions = lowered.evaluate_options && typeof lowered.evaluate_options === "object" && !Array.isArray(lowered.evaluate_options) ? { ...lowered.evaluate_options } : {};
+  if (budgetUsd !== void 0 && evaluateOptions.budget_usd === void 0) {
+    evaluateOptions.budget_usd = budgetUsd;
+  }
+  if (repeat !== void 0 && evaluateOptions.repeat === void 0) {
+    evaluateOptions.repeat = repeat;
+  }
+  return {
+    ...loweredWithoutRuntimeOptions,
+    evaluate_options: evaluateOptions
+  };
+}
+function validateRepeatValue(value, location) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error(
+      `defineEval() expects ${location} to be a positive integer; object-shaped repeat authoring has been removed.`
+    );
+  }
+}
+function attachEvalSuiteBrand(definition) {
+  validateTopLevelRuntimeFields(definition);
+  const branded = definition;
+  if (branded[EVAL_SUITE_SYMBOL] === true) {
+    return branded;
+  }
+  Object.defineProperties(branded, {
+    [EVAL_SUITE_SYMBOL]: {
+      value: true,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    },
+    [TO_EVAL_YAML_OBJECT_SYMBOL]: {
+      value: () => toEvalYamlObject(definition),
+      enumerable: false,
+      configurable: false,
+      writable: false
+    }
+  });
+  return branded;
+}
+function validateTopLevelRuntimeFields(definition) {
+  const rawDefinition = definition;
+  if (Object.prototype.hasOwnProperty.call(rawDefinition, "input")) {
+    throw new Error(
+      "defineEval() does not accept top-level 'input'. Use prompts with default test vars or tests[].vars instead."
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(rawDefinition, "preprocessors")) {
+    throw new Error(
+      "defineEval() does not accept top-level 'preprocessors'. Use defaultTest.options.transform or assertion-level transform instead."
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(rawDefinition, "graders")) {
+    throw new Error(
+      "defineEval() no longer accepts top-level 'graders'. Put grader providers in 'providers' and select them with defaults.grader, defaultTest.options.provider, tests[].options.provider, or assertion provider."
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(rawDefinition, "experiment")) {
+    throw new Error(
+      "defineEval() no longer accepts top-level 'experiment'. Use tags: { experiment: '<name>' } or CLI --experiment."
+    );
+  }
+  for (const field of ["model", "policy", "execution", "runs", "earlyExit"]) {
+    if (Object.prototype.hasOwnProperty.call(rawDefinition, field)) {
+      throw new Error(
+        `defineEval() does not accept top-level '${field}'. Put target overrides in target and repeat controls under repeat, which serializes to evaluate_options.repeat.`
+      );
+    }
+  }
+  validateRepeatValue(rawDefinition.repeat, "repeat");
+  if (Array.isArray(rawDefinition.tests)) {
+    rawDefinition.tests.forEach((test, index) => {
+      if (test && typeof test === "object" && Object.prototype.hasOwnProperty.call(test, "input")) {
+        throw new Error(
+          `defineEval() does not accept tests[${index}].input. Use prompts with tests[].vars instead.`
+        );
+      }
+      const options = test.options;
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        validateRepeatValue(
+          options.repeat,
+          `tests[${index}].options.repeat`
+        );
+      }
+    });
+  }
+  validateProviderSurface(definition);
+}
+function validateProviderSurface(definition) {
+  const visit = (value, path) => {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => visit(entry, `${path}[${index}]`));
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    const record = value;
+    if (path.endsWith(".defaults") && Object.prototype.hasOwnProperty.call(record, "target")) {
+      throw new Error("defineEval() no longer accepts 'defaults.target'. Use 'defaults.provider'.");
+    }
+    if (Object.prototype.hasOwnProperty.call(record, "target")) {
+      throw new Error(
+        `defineEval() no longer accepts '${path}.target'. Use '${path}.provider' or '${path}.providers' instead.`
+      );
+    }
+    if (Object.prototype.hasOwnProperty.call(record, "targets")) {
+      throw new Error(
+        `defineEval() no longer accepts '${path}.targets'. Use '${path}.providers' instead.`
+      );
+    }
+    for (const [key, nested] of Object.entries(record)) {
+      visit(nested, `${path}.${key}`);
+    }
+  };
+  visit(definition, "eval");
+}
+function defineEval(definition) {
+  return attachEvalSuiteBrand(definition);
+}
+function toEvalYamlObject(definition) {
+  return lowerEvalConfig(definition);
+}
+function serializeEvalYaml(definition) {
+  return stringifyYaml(toEvalYamlObject(definition), { lineWidth: 0 }).trimEnd();
+}
+function withCommon(config, options = {}) {
+  return {
+    ...options.metric !== void 0 ? { metric: options.metric } : {},
+    ...config,
+    ...options.weight !== void 0 ? { weight: options.weight } : {},
+    ...options.required !== void 0 ? { required: options.required } : {},
+    ...options.minScore !== void 0 ? { minScore: options.minScore } : {},
+    ...options.negate !== void 0 ? { negate: options.negate } : {},
+    ...options.transform !== void 0 ? { transform: options.transform } : {}
+  };
+}
+function containsGrader(value, options) {
+  return withCommon({ type: "contains", value }, options);
+}
+function equalsGrader(value, options) {
+  return withCommon({ type: "equals", value }, options);
+}
+function exactGrader(value, options) {
+  return equalsGrader(value, options);
+}
+function regexGrader(pattern, options = {}) {
+  const value = pattern instanceof RegExp ? pattern.source : pattern;
+  const flags = options.flags ?? (pattern instanceof RegExp ? pattern.flags : void 0);
+  return withCommon(
+    {
+      type: "regex",
+      value,
+      ...flags ? { flags } : {}
+    },
+    options
+  );
+}
+function isJsonGrader(options) {
+  return withCommon({ type: "is-json" }, options);
+}
+function jsonGrader(options) {
+  return isJsonGrader(options);
+}
+function llmRubricGrader(valueOrCriteria, options = {}) {
+  return withCommon(
+    {
+      type: "llm-rubric",
+      ...valueOrCriteria !== void 0 ? { value: valueOrCriteria } : {},
+      ...options.prompt !== void 0 ? { prompt: options.prompt } : {},
+      ...options.provider !== void 0 ? { provider: options.provider } : {},
+      ...options.config !== void 0 ? { config: options.config } : {},
+      ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {}
+    },
+    options
+  );
+}
+function codeGrader(command, options = {}) {
+  return scriptGrader(command, options);
+}
+function scriptGrader(command, options = {}) {
+  return withCommon(
+    {
+      type: "script",
+      command,
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+      ...options.provider !== void 0 ? { provider: options.provider } : {},
+      ...options.config !== void 0 ? { config: options.config } : {}
+    },
+    options
+  );
+}
+var graders = Object.freeze({
+  contains: containsGrader,
+  equals: equalsGrader,
+  exact: exactGrader,
+  regex: regexGrader,
+  isJson: isJsonGrader,
+  json: jsonGrader,
+  llmRubric: llmRubricGrader,
+  codeGrader,
+  script: scriptGrader,
+  scriptGrader
+});
+var ProviderNotAvailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProviderNotAvailableError";
+  }
+};
+var ProviderInvocationError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "ProviderInvocationError";
+    this.statusCode = statusCode;
+  }
+};
+function createProviderClient() {
+  const proxyUrl = process.env.AGENTV_PROVIDER_PROXY_URL;
+  const proxyToken = process.env.AGENTV_PROVIDER_PROXY_TOKEN;
+  if (!proxyUrl) {
+    return void 0;
+  }
+  if (!proxyToken) {
+    throw new ProviderNotAvailableError(
+      "AGENTV_PROVIDER_PROXY_URL is set but AGENTV_PROVIDER_PROXY_TOKEN is missing"
+    );
+  }
+  return createProviderClientInternal(proxyUrl, proxyToken);
+}
+function createProviderClientInternal(url, token) {
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${token}`
+  };
+  return {
+    async invoke(request) {
+      const response = await fetch(`${url}/invoke`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          question: request.question,
+          systemPrompt: request.systemPrompt,
+          evalCaseId: request.evalCaseId,
+          attempt: request.attempt,
+          provider: request.provider
+        })
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorBody);
+          errorMessage = errorJson.error ?? `HTTP ${response.status}`;
+        } catch {
+          errorMessage = errorBody || `HTTP ${response.status}`;
+        }
+        throw new ProviderInvocationError(errorMessage, response.status);
+      }
+      return await response.json();
+    },
+    async invokeBatch(requests) {
+      const response = await fetch(`${url}/invokeBatch`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          requests: requests.map((r) => ({
+            question: r.question,
+            systemPrompt: r.systemPrompt,
+            evalCaseId: r.evalCaseId,
+            attempt: r.attempt,
+            provider: r.provider
+          }))
+        })
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorBody);
+          errorMessage = errorJson.error ?? `HTTP ${response.status}`;
+        } catch {
+          errorMessage = errorBody || `HTTP ${response.status}`;
+        }
+        throw new ProviderInvocationError(errorMessage, response.status);
+      }
+      const result = await response.json();
+      return result.responses;
+    },
+    async getInfo() {
+      const response = await fetch(`${url}/info`, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorBody);
+          errorMessage = errorJson.error ?? `HTTP ${response.status}`;
+        } catch {
+          errorMessage = errorBody || `HTTP ${response.status}`;
+        }
+        throw new ProviderInvocationError(errorMessage, response.status);
+      }
+      return await response.json();
+    }
+  };
+}
+function workspacePathFrom(input) {
+  const workspacePath = input.workspacePath ?? process.env.AGENTV_WORKSPACE_PATH;
+  if (!workspacePath?.trim()) {
+    return void 0;
+  }
+  return workspacePath;
+}
+function normalizeDisplayPath(relativePath) {
+  return relativePath.split(nodePath.sep).join("/");
+}
+function resolveWorkspacePath(workspacePath, relativePath) {
+  const displayPath = normalizeDisplayPath(relativePath);
+  if (!workspacePath) {
+    return {
+      displayPath,
+      error: "Workspace path is not available. Configure an environment recipe in the eval YAML."
+    };
+  }
+  if (!relativePath.trim()) {
+    return { displayPath, error: "Workspace file path must not be empty." };
+  }
+  if (nodePath.isAbsolute(relativePath)) {
+    return {
+      displayPath,
+      error: `Workspace file path must be relative: ${displayPath}`
+    };
+  }
+  const root = nodePath.resolve(workspacePath);
+  const absolutePath = nodePath.resolve(root, relativePath);
+  const relativeToRoot = nodePath.relative(root, absolutePath);
+  if (relativeToRoot === "" || relativeToRoot.startsWith("..") || nodePath.isAbsolute(relativeToRoot)) {
+    return {
+      displayPath,
+      error: `Workspace file path must stay inside the workspace: ${displayPath}`
+    };
+  }
+  return {
+    displayPath: normalizeDisplayPath(relativeToRoot),
+    absolutePath
+  };
+}
+function check(text, pass, reason, evidence) {
+  return {
+    text,
+    pass,
+    reason,
+    ...evidence !== void 0 ? { evidence } : {}
+  };
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+function regexLabel(pattern) {
+  return `/${pattern.source}/${pattern.flags}`;
+}
+async function readFileForAssertion(file) {
+  try {
+    return { content: await file.readText() };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function isScriptGraderResult(value) {
+  return !Array.isArray(value) && typeof value === "object" && value !== null && "score" in value;
+}
+function createWorkspace(input) {
+  const workspacePath = workspacePathFrom(input);
+  const textCache = /* @__PURE__ */ new Map();
+  async function readText(relativePath) {
+    const resolved = resolveWorkspacePath(workspacePath, relativePath);
+    if (resolved.error) {
+      throw new Error(resolved.error);
+    }
+    const absolutePath = resolved.absolutePath;
+    if (!absolutePath) {
+      throw new Error(`Unable to resolve workspace file: ${resolved.displayPath}`);
+    }
+    let pendingRead = textCache.get(absolutePath);
+    if (!pendingRead) {
+      pendingRead = readFile(absolutePath, "utf8");
+      textCache.set(absolutePath, pendingRead);
+    }
+    return pendingRead;
+  }
+  function file(relativePath) {
+    const resolved = resolveWorkspacePath(workspacePath, relativePath);
+    const label = resolved.displayPath;
+    return {
+      path: label,
+      ...resolved.absolutePath !== void 0 ? { absolutePath: resolved.absolutePath } : {},
+      readText() {
+        return readText(relativePath);
+      },
+      async exists(options = {}) {
+        const text = options.text ?? `${label} exists`;
+        if (resolved.error) {
+          return check(text, false, resolved.error);
+        }
+        try {
+          const fileStat = await stat(resolved.absolutePath);
+          if (fileStat.isFile()) {
+            return check(text, true, `${label} exists.`);
+          }
+          return check(text, false, `${label} exists but is not a file.`);
+        } catch {
+          return check(text, false, `${label} does not exist.`);
+        }
+      },
+      async contains(expected, options = {}) {
+        const text = options.text ?? `${label} contains ${quote(expected)}`;
+        const content = await readFileForAssertion(this);
+        if ("error" in content) {
+          return check(text, false, content.error);
+        }
+        const pass = content.content.includes(expected);
+        return check(
+          text,
+          pass,
+          pass ? `${label} contains ${quote(expected)}.` : `${label} is missing ${quote(expected)}.`
+        );
+      },
+      async notContains(expected, options = {}) {
+        const text = options.text ?? `${label} does not contain ${quote(expected)}`;
+        const content = await readFileForAssertion(this);
+        if ("error" in content) {
+          return check(text, false, content.error);
+        }
+        const pass = !content.content.includes(expected);
+        return check(
+          text,
+          pass,
+          pass ? `${label} does not contain ${quote(expected)}.` : `${label} contains unexpected text ${quote(expected)}.`
+        );
+      },
+      async matches(pattern, options = {}) {
+        const text = options.text ?? `${label} matches ${regexLabel(pattern)}`;
+        const content = await readFileForAssertion(this);
+        if ("error" in content) {
+          return check(text, false, content.error);
+        }
+        pattern.lastIndex = 0;
+        const pass = pattern.test(content.content);
+        return check(
+          text,
+          pass,
+          pass ? `${label} matches ${regexLabel(pattern)}.` : `${label} does not match ${regexLabel(pattern)}.`
+        );
+      },
+      async notMatches(pattern, options = {}) {
+        const text = options.text ?? `${label} does not match ${regexLabel(pattern)}`;
+        const content = await readFileForAssertion(this);
+        if ("error" in content) {
+          return check(text, false, content.error);
+        }
+        pattern.lastIndex = 0;
+        const pass = !pattern.test(content.content);
+        return check(
+          text,
+          pass,
+          pass ? `${label} does not match ${regexLabel(pattern)}.` : `${label} matches unexpected pattern ${regexLabel(pattern)}.`
+        );
+      }
+    };
+  }
+  return {
+    ...workspacePath !== void 0 ? { path: workspacePath } : {},
+    file,
+    readText
+  };
+}
+async function normalizeWorkspaceGraderResult(result) {
+  if (isScriptGraderResult(result)) {
+    return ScriptGraderResultSchema.parse(result);
+  }
+  const checks = Array.isArray(result) ? await Promise.all(result) : [result];
+  const passed = checks.filter((item) => item.pass).length;
+  const score = checks.length > 0 ? checks.reduce((sum, item) => sum + (item.score ?? (item.pass ? 1 : 0)), 0) / checks.length : 0;
+  return ScriptGraderResultSchema.parse({
+    pass: checks.length > 0 && passed === checks.length,
+    score,
+    reason: checks.length > 0 ? `${passed}/${checks.length} checks passed.` : "No checks ran.",
+    checks
+  });
+}
+async function runWorkspaceGrader(handler, input) {
+  return normalizeWorkspaceGraderResult(
+    await handler({
+      ...input,
+      workspace: createWorkspace(input)
+    })
+  );
+}
+function defineWorkspaceGrader(handler) {
+  runScriptGrader((input) => runWorkspaceGrader(handler, input));
+}
+function enrichInput(input) {
+  return input;
+}
+function readStdin() {
+  return readFileSync(0, "utf8");
+}
+function clampScore(value) {
+  if (Number.isNaN(value) || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function normalizeScore(result) {
+  let score;
+  if (result.score !== void 0) {
+    score = clampScore(result.score);
+  } else if (result.pass !== void 0) {
+    score = result.pass ? 1 : 0;
+  } else {
+    score = 0;
+  }
+  const pass = result.pass ?? score >= 0.5;
+  return {
+    pass,
+    score,
+    reason: result.reason ?? (pass ? "Assertion passed" : "Assertion failed"),
+    checks: result.checks ? result.checks.map((check2) => ({
+      ...check2,
+      ...check2.score !== void 0 ? { score: clampScore(check2.score) } : {}
+    })) : [],
+    details: result.details
+  };
+}
+async function runAssertion(handler) {
+  try {
+    const stdin = readStdin();
+    const rawInput = JSON.parse(stdin);
+    const camelInput = toCamelCaseDeep(rawInput);
+    const input = ScriptGraderInputSchema.parse(camelInput);
+    if (input.outputPath && (input.output === null || input.output === void 0)) {
+      let cachedOutput;
+      const filePath = input.outputPath;
+      Object.defineProperty(input, "output", {
+        get() {
+          if (cachedOutput === void 0) {
+            cachedOutput = JSON.parse(readFileSync(filePath, "utf8"));
+          }
+          return cachedOutput;
+        },
+        configurable: true,
+        enumerable: true
+      });
+    }
+    enrichInput(input);
+    const rawResult = await handler(input);
+    const normalized = normalizeScore(rawResult);
+    const result = ScriptGraderResultSchema.parse(normalized);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    const errorMessage = formatError(error);
+    const errorResult = {
+      pass: false,
+      score: 0,
+      reason: `Assertion failed: ${errorMessage}`,
+      checks: [{ text: "Assertion execution", pass: false, reason: errorMessage }]
+    };
+    console.log(JSON.stringify(errorResult, null, 2));
+    process.exit(1);
+  }
+}
+function readStdin2() {
+  return readFileSync2(0, "utf8");
+}
+async function runPromptTemplate(handler) {
+  try {
+    const stdin = readStdin2();
+    const rawInput = JSON.parse(stdin);
+    const camelInput = toCamelCaseDeep(rawInput);
+    const input = PromptTemplateInputSchema.parse(camelInput);
+    enrichInput(input);
+    const prompt = await handler(input);
+    console.log(prompt);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function defineScriptGrader(handler) {
+  runScriptGrader(handler);
+}
+function defineCodeGrader(handler) {
+  defineScriptGrader(handler);
+}
+function definePromptTemplate(handler) {
+  runPromptTemplate(handler);
+}
+function defineAssertion(handler) {
+  runAssertion(handler);
+}
+
+export {
+  defineEval,
+  toEvalYamlObject,
+  serializeEvalYaml,
+  containsGrader,
+  equalsGrader,
+  exactGrader,
+  regexGrader,
+  isJsonGrader,
+  jsonGrader,
+  llmRubricGrader,
+  codeGrader,
+  scriptGrader,
+  graders,
+  ProviderNotAvailableError,
+  ProviderInvocationError,
+  createProviderClient,
+  createWorkspace,
+  normalizeWorkspaceGraderResult,
+  runWorkspaceGrader,
+  defineWorkspaceGrader,
+  defineScriptGrader,
+  defineCodeGrader,
+  definePromptTemplate,
+  defineAssertion
+};
+//# sourceMappingURL=chunk-MMDLXYBX.js.map