@agentv/sdk 4.41.3-next.1 → 4.41.4-next.1

package/dist/index.cjs

@@ -0,0 +1,623 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CodeGraderInputSchema: () => CodeGraderInputSchema,
+  CodeGraderResultSchema: () => CodeGraderResultSchema,
+  ContentFileSchema: () => ContentFileSchema,
+  ContentImageSchema: () => ContentImageSchema,
+  ContentSchema: () => ContentSchema,
+  ContentTextSchema: () => ContentTextSchema,
+  MessageSchema: () => MessageSchema,
+  PromptTemplateInputSchema: () => PromptTemplateInputSchema,
+  TRACE_EVENT_TYPES: () => TRACE_EVENT_TYPES,
+  TRACE_REDACTION_LEVELS: () => TRACE_REDACTION_LEVELS,
+  TRACE_SOURCE_KINDS: () => TRACE_SOURCE_KINDS,
+  TRACE_TOOL_STATUSES: () => TRACE_TOOL_STATUSES,
+  TargetInvocationError: () => TargetInvocationError,
+  TargetNotAvailableError: () => TargetNotAvailableError,
+  TokenUsageSchema: () => TokenUsageSchema,
+  ToolCallSchema: () => ToolCallSchema,
+  TraceArtifactSchema: () => TraceArtifactSchema,
+  TraceBranchSchema: () => TraceBranchSchema,
+  TraceErrorSchema: () => TraceErrorSchema,
+  TraceEventSchema: () => TraceEventSchema,
+  TraceMessageSchema: () => TraceMessageSchema,
+  TraceModelSchema: () => TraceModelSchema,
+  TraceRawEvidenceSchema: () => TraceRawEvidenceSchema,
+  TraceRedactionStateSchema: () => TraceRedactionStateSchema,
+  TraceSchema: () => TraceSchema,
+  TraceSessionSchema: () => TraceSessionSchema,
+  TraceSourceRefSchema: () => TraceSourceRefSchema,
+  TraceSourceSchema: () => TraceSourceSchema,
+  TraceSummarySchema: () => TraceSummarySchema,
+  TraceToolSchema: () => TraceToolSchema,
+  createTargetClient: () => createTargetClient,
+  defineAssertion: () => defineAssertion,
+  defineCodeGrader: () => defineCodeGrader,
+  definePromptTemplate: () => definePromptTemplate,
+  z: () => import_zod2.z
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schemas.ts
+var import_zod = require("zod");
+var TokenUsageSchema = import_zod.z.object({
+  input: import_zod.z.number(),
+  output: import_zod.z.number(),
+  cached: import_zod.z.number().optional(),
+  reasoning: import_zod.z.number().optional()
+});
+var TraceSummarySchema = import_zod.z.object({
+  eventCount: import_zod.z.number(),
+  toolCalls: import_zod.z.record(import_zod.z.string(), import_zod.z.number()),
+  errorCount: import_zod.z.number(),
+  toolDurations: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.number())).optional(),
+  llmCallCount: import_zod.z.number().optional()
+});
+var TRACE_SOURCE_KINDS = [
+  "agentv_run",
+  "otlp",
+  "phoenix",
+  "langfuse",
+  "pi_session",
+  "imported_transcript",
+  "compact_transcript"
+];
+var TRACE_EVENT_TYPES = [
+  "message",
+  "model_turn",
+  "tool_call",
+  "tool_result",
+  "final_response",
+  "error"
+];
+var TRACE_TOOL_STATUSES = ["ok", "error", "timeout", "cancelled", "unknown"];
+var TRACE_REDACTION_LEVELS = ["none", "partial", "full"];
+var MetadataSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.unknown());
+var TraceRedactionStateSchema = import_zod.z.object({
+  level: import_zod.z.enum(TRACE_REDACTION_LEVELS),
+  fields: import_zod.z.array(import_zod.z.string()).optional(),
+  reason: import_zod.z.string().optional()
+});
+var TraceErrorSchema = import_zod.z.object({
+  message: import_zod.z.string(),
+  name: import_zod.z.string().optional(),
+  code: import_zod.z.string().optional(),
+  stack: import_zod.z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceSourceSchema = import_zod.z.object({
+  kind: import_zod.z.enum(TRACE_SOURCE_KINDS),
+  path: import_zod.z.string().optional(),
+  url: import_zod.z.string().optional(),
+  provider: import_zod.z.string().optional(),
+  format: import_zod.z.string().optional(),
+  version: import_zod.z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceSessionSchema = import_zod.z.object({
+  sessionId: import_zod.z.string().optional(),
+  conversationId: import_zod.z.string().optional(),
+  cwd: import_zod.z.string().optional(),
+  startedAt: import_zod.z.string().optional(),
+  endedAt: import_zod.z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceBranchSchema = import_zod.z.object({
+  selectedLeafId: import_zod.z.string().optional(),
+  selectedPathIds: import_zod.z.array(import_zod.z.string()).optional(),
+  includedEventIds: import_zod.z.array(import_zod.z.string()).optional(),
+  omittedEventIds: import_zod.z.array(import_zod.z.string()).optional(),
+  selectionReason: import_zod.z.string().optional()
+});
+var TraceSourceRefSchema = import_zod.z.object({
+  eventId: import_zod.z.string().optional(),
+  messageId: import_zod.z.string().optional(),
+  spanId: import_zod.z.string().optional(),
+  traceId: import_zod.z.string().optional(),
+  rawKind: import_zod.z.string().optional(),
+  path: import_zod.z.string().optional(),
+  line: import_zod.z.number().int().nonnegative().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceRawEvidenceSchema = import_zod.z.object({
+  kind: import_zod.z.string(),
+  ref: import_zod.z.string().optional(),
+  mediaType: import_zod.z.string().optional(),
+  content: import_zod.z.unknown().optional(),
+  redacted: import_zod.z.boolean().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceMessageSchema = import_zod.z.object({
+  role: import_zod.z.string(),
+  name: import_zod.z.string().optional(),
+  content: import_zod.z.unknown().optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceModelSchema = import_zod.z.object({
+  provider: import_zod.z.string().optional(),
+  name: import_zod.z.string().optional(),
+  invocationId: import_zod.z.string().optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceToolSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  callId: import_zod.z.string().optional(),
+  input: import_zod.z.unknown().optional(),
+  output: import_zod.z.unknown().optional(),
+  status: import_zod.z.enum(TRACE_TOOL_STATUSES).optional(),
+  error: TraceErrorSchema.optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceEventSchema = import_zod.z.object({
+  eventId: import_zod.z.string(),
+  parentEventId: import_zod.z.string().optional(),
+  ordinal: import_zod.z.number().int().nonnegative(),
+  type: import_zod.z.enum(TRACE_EVENT_TYPES),
+  timestamp: import_zod.z.string().optional(),
+  durationMs: import_zod.z.number().nonnegative().optional(),
+  durationInferred: import_zod.z.boolean().optional(),
+  turnIndex: import_zod.z.number().int().nonnegative().optional(),
+  message: TraceMessageSchema.optional(),
+  model: TraceModelSchema.optional(),
+  tool: TraceToolSchema.optional(),
+  error: TraceErrorSchema.optional(),
+  sourceRef: TraceSourceRefSchema.optional(),
+  rawEvidence: import_zod.z.array(TraceRawEvidenceSchema).optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceArtifactSchema = import_zod.z.object({
+  source: TraceSourceSchema,
+  session: TraceSessionSchema,
+  branch: TraceBranchSchema.optional(),
+  events: import_zod.z.array(TraceEventSchema),
+  tokenUsage: TokenUsageSchema.optional(),
+  costUsd: import_zod.z.number().optional(),
+  durationMs: import_zod.z.number().optional(),
+  startedAt: import_zod.z.string().optional(),
+  endedAt: import_zod.z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var ToolCallSchema = import_zod.z.object({
+  tool: import_zod.z.string(),
+  input: import_zod.z.unknown().optional(),
+  output: import_zod.z.unknown().optional(),
+  id: import_zod.z.string().optional(),
+  startTime: import_zod.z.string().optional(),
+  endTime: import_zod.z.string().optional(),
+  durationMs: import_zod.z.number().optional()
+});
+var ContentTextSchema = import_zod.z.object({
+  type: import_zod.z.literal("text"),
+  text: import_zod.z.string()
+});
+var ContentImageSchema = import_zod.z.object({
+  type: import_zod.z.literal("image"),
+  media_type: import_zod.z.string(),
+  path: import_zod.z.string()
+});
+var ContentFileSchema = import_zod.z.object({
+  type: import_zod.z.literal("file"),
+  media_type: import_zod.z.string(),
+  path: import_zod.z.string()
+});
+var ContentSchema = import_zod.z.discriminatedUnion("type", [
+  ContentTextSchema,
+  ContentImageSchema,
+  ContentFileSchema
+]);
+var MessageContentBlockSchema = import_zod.z.union([ContentSchema, import_zod.z.record(import_zod.z.unknown())]);
+var MessageSchema = import_zod.z.object({
+  role: import_zod.z.enum(["assistant", "user", "system", "tool"]),
+  content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(MessageContentBlockSchema), import_zod.z.record(import_zod.z.unknown())]).optional(),
+  toolCalls: import_zod.z.array(ToolCallSchema).optional(),
+  name: import_zod.z.string().optional(),
+  startTime: import_zod.z.string().optional(),
+  endTime: import_zod.z.string().optional(),
+  durationMs: import_zod.z.number().optional(),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var TraceSchema = TraceSummarySchema.extend({
+  messages: import_zod.z.array(MessageSchema),
+  events: import_zod.z.array(TraceEventSchema),
+  tokenUsage: TokenUsageSchema.optional(),
+  costUsd: import_zod.z.number().optional(),
+  durationMs: import_zod.z.number().optional(),
+  startTime: import_zod.z.string().optional(),
+  endTime: import_zod.z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var CodeGraderInputSchema = import_zod.z.object({
+  criteria: import_zod.z.string(),
+  expectedOutput: import_zod.z.array(MessageSchema),
+  output: import_zod.z.string().nullable().optional(),
+  messages: import_zod.z.array(MessageSchema).optional().default([]),
+  /** Path to a temp file containing the output JSON (used for large payloads). */
+  outputPath: import_zod.z.string().optional(),
+  inputFiles: import_zod.z.array(import_zod.z.string()),
+  input: import_zod.z.array(MessageSchema),
+  metadata: import_zod.z.record(import_zod.z.unknown()).nullable().optional(),
+  trace: TraceSchema.nullable().optional(),
+  traceSummary: TraceSummarySchema.nullable().optional(),
+  tokenUsage: TokenUsageSchema.nullable().optional(),
+  costUsd: import_zod.z.number().nullable().optional(),
+  durationMs: import_zod.z.number().nullable().optional(),
+  startTime: import_zod.z.string().nullable().optional(),
+  endTime: import_zod.z.string().nullable().optional(),
+  fileChanges: import_zod.z.string().nullable().optional(),
+  workspacePath: import_zod.z.string().nullable().optional(),
+  config: import_zod.z.record(import_zod.z.unknown()).nullable().optional()
+});
+var CodeGraderResultSchema = import_zod.z.object({
+  score: import_zod.z.number().min(0).max(1),
+  assertions: import_zod.z.array(
+    import_zod.z.object({
+      text: import_zod.z.string(),
+      passed: import_zod.z.boolean(),
+      evidence: import_zod.z.string().optional()
+    })
+  ).optional().default([]),
+  /** Optional structured details for domain-specific metrics (e.g., TP/TN/FP/FN counts, alignments). */
+  details: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var PromptTemplateInputSchema = CodeGraderInputSchema;
+
+// src/target-client.ts
+var TargetNotAvailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TargetNotAvailableError";
+  }
+};
+var TargetInvocationError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "TargetInvocationError";
+    this.statusCode = statusCode;
+  }
+};
+function createTargetClient() {
+  const proxyUrl = process.env.AGENTV_TARGET_PROXY_URL;
+  const proxyToken = process.env.AGENTV_TARGET_PROXY_TOKEN;
+  if (!proxyUrl) {
+    return void 0;
+  }
+  if (!proxyToken) {
+    throw new TargetNotAvailableError(
+      "AGENTV_TARGET_PROXY_URL is set but AGENTV_TARGET_PROXY_TOKEN is missing"
+    );
+  }
+  return createTargetClientInternal(proxyUrl, proxyToken);
+}
+function createTargetClientInternal(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,
+          target: request.target
+        })
+      });
+      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 TargetInvocationError(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,
+            target: r.target
+          }))
+        })
+      });
+      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 TargetInvocationError(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 TargetInvocationError(errorMessage, response.status);
+      }
+      return await response.json();
+    }
+  };
+}
+
+// src/index.ts
+var import_zod2 = require("zod");
+
+// src/assertion.ts
+var import_node_fs = require("fs");
+
+// src/case-conversion.ts
+function toCamelCase(str) {
+  if (/^[A-Z]/.test(str)) {
+    return str;
+  }
+  return str.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+function toCamelCaseDeep(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toCamelCaseDeep(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const camelKey = toCamelCase(key);
+      result[camelKey] = toCamelCaseDeep(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/deprecation.ts
+function enrichInput(input) {
+  return input;
+}
+
+// src/assertion.ts
+function readStdin() {
+  return (0, import_node_fs.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;
+  }
+  return {
+    score,
+    assertions: result.assertions ? [...result.assertions] : [],
+    details: result.details
+  };
+}
+async function runAssertion(handler) {
+  try {
+    const stdin = readStdin();
+    const rawInput = JSON.parse(stdin);
+    const camelInput = toCamelCaseDeep(rawInput);
+    const input = CodeGraderInputSchema.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((0, import_node_fs.readFileSync)(filePath, "utf8"));
+          }
+          return cachedOutput;
+        },
+        configurable: true,
+        enumerable: true
+      });
+    }
+    enrichInput(input);
+    const rawResult = await handler(input);
+    const normalized = normalizeScore(rawResult);
+    const result = CodeGraderResultSchema.parse(normalized);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    const errorMessage = formatError(error);
+    const errorResult = {
+      score: 0,
+      assertions: [{ text: `Assertion failed: ${errorMessage}`, passed: false }]
+    };
+    console.log(JSON.stringify(errorResult, null, 2));
+    process.exit(1);
+  }
+}
+
+// src/prompt-template.ts
+var import_node_fs2 = require("fs");
+function readStdin2() {
+  return (0, import_node_fs2.readFileSync)(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);
+  }
+}
+
+// src/runtime.ts
+var import_node_fs3 = require("fs");
+function readStdin3() {
+  return (0, import_node_fs3.readFileSync)(0, "utf8");
+}
+function clampScore2(value) {
+  if (Number.isNaN(value) || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function formatError2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function runCodeGrader(handler) {
+  try {
+    const stdin = readStdin3();
+    const rawInput = JSON.parse(stdin);
+    const camelInput = toCamelCaseDeep(rawInput);
+    const input = CodeGraderInputSchema.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((0, import_node_fs3.readFileSync)(filePath, "utf8"));
+          }
+          return cachedOutput;
+        },
+        configurable: true,
+        enumerable: true
+      });
+    }
+    enrichInput(input);
+    const rawResult = await handler(input);
+    const result = CodeGraderResultSchema.parse({
+      ...rawResult,
+      score: clampScore2(rawResult.score)
+    });
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    const errorMessage = formatError2(error);
+    const errorResult = {
+      score: 0,
+      assertions: [{ text: `Evaluation failed: ${errorMessage}`, passed: false }]
+    };
+    console.log(JSON.stringify(errorResult, null, 2));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+function defineCodeGrader(handler) {
+  runCodeGrader(handler);
+}
+function definePromptTemplate(handler) {
+  runPromptTemplate(handler);
+}
+function defineAssertion(handler) {
+  runAssertion(handler);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodeGraderInputSchema,
+  CodeGraderResultSchema,
+  ContentFileSchema,
+  ContentImageSchema,
+  ContentSchema,
+  ContentTextSchema,
+  MessageSchema,
+  PromptTemplateInputSchema,
+  TRACE_EVENT_TYPES,
+  TRACE_REDACTION_LEVELS,
+  TRACE_SOURCE_KINDS,
+  TRACE_TOOL_STATUSES,
+  TargetInvocationError,
+  TargetNotAvailableError,
+  TokenUsageSchema,
+  ToolCallSchema,
+  TraceArtifactSchema,
+  TraceBranchSchema,
+  TraceErrorSchema,
+  TraceEventSchema,
+  TraceMessageSchema,
+  TraceModelSchema,
+  TraceRawEvidenceSchema,
+  TraceRedactionStateSchema,
+  TraceSchema,
+  TraceSessionSchema,
+  TraceSourceRefSchema,
+  TraceSourceSchema,
+  TraceSummarySchema,
+  TraceToolSchema,
+  createTargetClient,
+  defineAssertion,
+  defineCodeGrader,
+  definePromptTemplate,
+  z
+});
+//# sourceMappingURL=index.cjs.map