@agentv/sdk 4.41.3-next.1 → 4.41.4

package/dist/index.js

@@ -0,0 +1,562 @@
+// src/schemas.ts
+import { z } from "zod";
+var TokenUsageSchema = z.object({
+  input: z.number(),
+  output: z.number(),
+  cached: z.number().optional(),
+  reasoning: z.number().optional()
+});
+var TraceSummarySchema = z.object({
+  eventCount: z.number(),
+  toolCalls: z.record(z.string(), z.number()),
+  errorCount: z.number(),
+  toolDurations: z.record(z.string(), z.array(z.number())).optional(),
+  llmCallCount: 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 = z.record(z.string(), z.unknown());
+var TraceRedactionStateSchema = z.object({
+  level: z.enum(TRACE_REDACTION_LEVELS),
+  fields: z.array(z.string()).optional(),
+  reason: z.string().optional()
+});
+var TraceErrorSchema = z.object({
+  message: z.string(),
+  name: z.string().optional(),
+  code: z.string().optional(),
+  stack: z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceSourceSchema = z.object({
+  kind: z.enum(TRACE_SOURCE_KINDS),
+  path: z.string().optional(),
+  url: z.string().optional(),
+  provider: z.string().optional(),
+  format: z.string().optional(),
+  version: z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceSessionSchema = z.object({
+  sessionId: z.string().optional(),
+  conversationId: z.string().optional(),
+  cwd: z.string().optional(),
+  startedAt: z.string().optional(),
+  endedAt: z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceBranchSchema = z.object({
+  selectedLeafId: z.string().optional(),
+  selectedPathIds: z.array(z.string()).optional(),
+  includedEventIds: z.array(z.string()).optional(),
+  omittedEventIds: z.array(z.string()).optional(),
+  selectionReason: z.string().optional()
+});
+var TraceSourceRefSchema = z.object({
+  eventId: z.string().optional(),
+  messageId: z.string().optional(),
+  spanId: z.string().optional(),
+  traceId: z.string().optional(),
+  rawKind: z.string().optional(),
+  path: z.string().optional(),
+  line: z.number().int().nonnegative().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceRawEvidenceSchema = z.object({
+  kind: z.string(),
+  ref: z.string().optional(),
+  mediaType: z.string().optional(),
+  content: z.unknown().optional(),
+  redacted: z.boolean().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceMessageSchema = z.object({
+  role: z.string(),
+  name: z.string().optional(),
+  content: z.unknown().optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceModelSchema = z.object({
+  provider: z.string().optional(),
+  name: z.string().optional(),
+  invocationId: z.string().optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceToolSchema = z.object({
+  name: z.string(),
+  callId: z.string().optional(),
+  input: z.unknown().optional(),
+  output: z.unknown().optional(),
+  status: z.enum(TRACE_TOOL_STATUSES).optional(),
+  error: TraceErrorSchema.optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceEventSchema = z.object({
+  eventId: z.string(),
+  parentEventId: z.string().optional(),
+  ordinal: z.number().int().nonnegative(),
+  type: z.enum(TRACE_EVENT_TYPES),
+  timestamp: z.string().optional(),
+  durationMs: z.number().nonnegative().optional(),
+  durationInferred: z.boolean().optional(),
+  turnIndex: z.number().int().nonnegative().optional(),
+  message: TraceMessageSchema.optional(),
+  model: TraceModelSchema.optional(),
+  tool: TraceToolSchema.optional(),
+  error: TraceErrorSchema.optional(),
+  sourceRef: TraceSourceRefSchema.optional(),
+  rawEvidence: z.array(TraceRawEvidenceSchema).optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceArtifactSchema = z.object({
+  source: TraceSourceSchema,
+  session: TraceSessionSchema,
+  branch: TraceBranchSchema.optional(),
+  events: z.array(TraceEventSchema),
+  tokenUsage: TokenUsageSchema.optional(),
+  costUsd: z.number().optional(),
+  durationMs: z.number().optional(),
+  startedAt: z.string().optional(),
+  endedAt: z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var ToolCallSchema = z.object({
+  tool: z.string(),
+  input: z.unknown().optional(),
+  output: z.unknown().optional(),
+  id: z.string().optional(),
+  startTime: z.string().optional(),
+  endTime: z.string().optional(),
+  durationMs: z.number().optional()
+});
+var ContentTextSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+var ContentImageSchema = z.object({
+  type: z.literal("image"),
+  media_type: z.string(),
+  path: z.string()
+});
+var ContentFileSchema = z.object({
+  type: z.literal("file"),
+  media_type: z.string(),
+  path: z.string()
+});
+var ContentSchema = z.discriminatedUnion("type", [
+  ContentTextSchema,
+  ContentImageSchema,
+  ContentFileSchema
+]);
+var MessageContentBlockSchema = z.union([ContentSchema, z.record(z.unknown())]);
+var MessageSchema = z.object({
+  role: z.enum(["assistant", "user", "system", "tool"]),
+  content: z.union([z.string(), z.array(MessageContentBlockSchema), z.record(z.unknown())]).optional(),
+  toolCalls: z.array(ToolCallSchema).optional(),
+  name: z.string().optional(),
+  startTime: z.string().optional(),
+  endTime: z.string().optional(),
+  durationMs: z.number().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var TraceSchema = TraceSummarySchema.extend({
+  messages: z.array(MessageSchema),
+  events: z.array(TraceEventSchema),
+  tokenUsage: TokenUsageSchema.optional(),
+  costUsd: z.number().optional(),
+  durationMs: z.number().optional(),
+  startTime: z.string().optional(),
+  endTime: z.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var CodeGraderInputSchema = z.object({
+  criteria: z.string(),
+  expectedOutput: z.array(MessageSchema),
+  output: z.string().nullable().optional(),
+  messages: z.array(MessageSchema).optional().default([]),
+  /** Path to a temp file containing the output JSON (used for large payloads). */
+  outputPath: z.string().optional(),
+  inputFiles: z.array(z.string()),
+  input: z.array(MessageSchema),
+  metadata: z.record(z.unknown()).nullable().optional(),
+  trace: TraceSchema.nullable().optional(),
+  traceSummary: TraceSummarySchema.nullable().optional(),
+  tokenUsage: TokenUsageSchema.nullable().optional(),
+  costUsd: z.number().nullable().optional(),
+  durationMs: z.number().nullable().optional(),
+  startTime: z.string().nullable().optional(),
+  endTime: z.string().nullable().optional(),
+  fileChanges: z.string().nullable().optional(),
+  workspacePath: z.string().nullable().optional(),
+  config: z.record(z.unknown()).nullable().optional()
+});
+var CodeGraderResultSchema = z.object({
+  score: z.number().min(0).max(1),
+  assertions: z.array(
+    z.object({
+      text: z.string(),
+      passed: z.boolean(),
+      evidence: z.string().optional()
+    })
+  ).optional().default([]),
+  /** Optional structured details for domain-specific metrics (e.g., TP/TN/FP/FN counts, alignments). */
+  details: z.record(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
+import { z as z2 } from "zod";
+
+// src/assertion.ts
+import { readFileSync } from "node: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 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(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
+import { readFileSync as readFileSync2 } from "node:fs";
+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);
+  }
+}
+
+// src/runtime.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+function readStdin3() {
+  return readFileSync3(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(readFileSync3(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);
+}
+export {
+  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,
+  z2 as z
+};
+//# sourceMappingURL=index.js.map