@assemble-dev/shared-types 0.1.0

package/dist/trace-events.cjs

@@ -0,0 +1,399 @@
+"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/trace-events.ts
+var trace_events_exports = {};
+__export(trace_events_exports, {
+  AgentCompletedEventSchema: () => AgentCompletedEventSchema,
+  AgentFailedEventSchema: () => AgentFailedEventSchema,
+  AgentStartedEventSchema: () => AgentStartedEventSchema,
+  ApprovalApprovedEventSchema: () => ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema: () => ApprovalRejectedEventSchema,
+  ApprovalRequiredEventSchema: () => ApprovalRequiredEventSchema,
+  EvalCompletedEventSchema: () => EvalCompletedEventSchema,
+  EvalStartedEventSchema: () => EvalStartedEventSchema,
+  PolicyEvaluatedEventSchema: () => PolicyEvaluatedEventSchema,
+  ReplayCompletedEventSchema: () => ReplayCompletedEventSchema,
+  ReplayStartedEventSchema: () => ReplayStartedEventSchema,
+  RouteSelectedEventSchema: () => RouteSelectedEventSchema,
+  RunCompletedEventSchema: () => RunCompletedEventSchema,
+  RunFailedEventSchema: () => RunFailedEventSchema,
+  RunStartedEventSchema: () => RunStartedEventSchema,
+  ToolApprovedEventSchema: () => ToolApprovedEventSchema,
+  ToolBlockedEventSchema: () => ToolBlockedEventSchema,
+  ToolCompletedEventSchema: () => ToolCompletedEventSchema,
+  ToolFailedEventSchema: () => ToolFailedEventSchema,
+  ToolRequestedEventSchema: () => ToolRequestedEventSchema,
+  TraceEventErrorSchema: () => TraceEventErrorSchema,
+  TraceEventSchema: () => TraceEventSchema,
+  traceEventTypes: () => traceEventTypes
+});
+module.exports = __toCommonJS(trace_events_exports);
+var import_zod4 = require("zod");
+
+// src/json.ts
+var import_zod = require("zod");
+var JsonPrimitiveSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null()
+]);
+var JsonValueSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    JsonPrimitiveSchema,
+    import_zod.z.array(JsonValueSchema),
+    import_zod.z.record(import_zod.z.string(), JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = import_zod.z.record(import_zod.z.string(), JsonValueSchema);
+
+// src/run-metadata.ts
+var import_zod2 = require("zod");
+var RunMetadataSchema = import_zod2.z.object({
+  sessionId: import_zod2.z.string().optional(),
+  userId: import_zod2.z.string().optional(),
+  tags: import_zod2.z.array(import_zod2.z.string()).optional(),
+  parentTraceId: import_zod2.z.string().optional(),
+  parentSpanId: import_zod2.z.string().optional()
+});
+
+// src/runs.ts
+var import_zod3 = require("zod");
+var RunStatusSchema = import_zod3.z.enum([
+  "pending",
+  "running",
+  "awaiting_approval",
+  "completed",
+  "failed",
+  "canceled",
+  "rejected"
+]);
+var PolicyActionSchema = import_zod3.z.enum([
+  "allow",
+  "block",
+  "requireApproval",
+  "logOnly",
+  "redact"
+]);
+var ApprovalStatusSchema = import_zod3.z.enum(["pending", "approved", "rejected"]);
+var RunErrorSchema = import_zod3.z.object({
+  message: import_zod3.z.string(),
+  code: import_zod3.z.string().optional(),
+  agentName: import_zod3.z.string().optional(),
+  toolName: import_zod3.z.string().optional(),
+  timestamp: import_zod3.z.iso.datetime()
+});
+var RunMessageRoleSchema = import_zod3.z.enum([
+  "system",
+  "user",
+  "assistant",
+  "tool"
+]);
+var RunMessageSchema = import_zod3.z.object({
+  role: RunMessageRoleSchema,
+  content: import_zod3.z.string(),
+  agentName: import_zod3.z.string().optional(),
+  toolName: import_zod3.z.string().optional(),
+  timestamp: import_zod3.z.iso.datetime()
+});
+var AgentCallStatusSchema = import_zod3.z.enum(["running", "completed", "failed"]);
+var AgentCallSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  agentName: import_zod3.z.string(),
+  status: AgentCallStatusSchema,
+  input: JsonValueSchema,
+  output: JsonValueSchema.nullable(),
+  error: RunErrorSchema.nullable(),
+  startedAt: import_zod3.z.iso.datetime(),
+  completedAt: import_zod3.z.iso.datetime().nullable(),
+  latencyMs: import_zod3.z.number().nonnegative().nullable()
+});
+var ToolCallStatusSchema = import_zod3.z.enum([
+  "requested",
+  "approved",
+  "blocked",
+  "completed",
+  "failed"
+]);
+var ToolCallSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  toolName: import_zod3.z.string(),
+  agentName: import_zod3.z.string(),
+  status: ToolCallStatusSchema,
+  input: JsonValueSchema,
+  output: JsonValueSchema.nullable(),
+  error: RunErrorSchema.nullable(),
+  requestedAt: import_zod3.z.iso.datetime(),
+  completedAt: import_zod3.z.iso.datetime().nullable(),
+  latencyMs: import_zod3.z.number().nonnegative().nullable()
+});
+var PolicyDecisionSchema = import_zod3.z.object({
+  policyName: import_zod3.z.string(),
+  action: PolicyActionSchema,
+  agentName: import_zod3.z.string().optional(),
+  toolName: import_zod3.z.string().optional(),
+  reason: import_zod3.z.string(),
+  timestamp: import_zod3.z.iso.datetime()
+});
+var RoutingDecisionSchema = import_zod3.z.object({
+  supervisorName: import_zod3.z.string(),
+  selectedAgentName: import_zod3.z.string(),
+  candidateAgentNames: import_zod3.z.array(import_zod3.z.string()),
+  reason: import_zod3.z.string(),
+  timestamp: import_zod3.z.iso.datetime()
+});
+var RunApprovalSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  status: ApprovalStatusSchema,
+  toolCallId: import_zod3.z.string().nullable(),
+  toolName: import_zod3.z.string().optional(),
+  agentName: import_zod3.z.string().optional(),
+  reason: import_zod3.z.string(),
+  requestedAt: import_zod3.z.iso.datetime(),
+  decidedAt: import_zod3.z.iso.datetime().nullable(),
+  decidedBy: import_zod3.z.string().nullable()
+});
+var RunArtifactSchema = import_zod3.z.object({
+  key: import_zod3.z.string(),
+  value: JsonValueSchema,
+  producedByAgentName: import_zod3.z.string().optional(),
+  createdAt: import_zod3.z.iso.datetime()
+});
+var TokenUsageSchema = import_zod3.z.object({
+  inputTokens: import_zod3.z.number().int().nonnegative(),
+  outputTokens: import_zod3.z.number().int().nonnegative(),
+  totalTokens: import_zod3.z.number().int().nonnegative(),
+  cacheCreationInputTokens: import_zod3.z.number().int().nonnegative().optional(),
+  cacheReadInputTokens: import_zod3.z.number().int().nonnegative().optional()
+});
+var RunMetricsSchema = import_zod3.z.object({
+  totalLatencyMs: import_zod3.z.number().nonnegative().nullable(),
+  tokenUsage: TokenUsageSchema.nullable(),
+  agentCallCount: import_zod3.z.number().int().nonnegative(),
+  toolCallCount: import_zod3.z.number().int().nonnegative(),
+  policyDecisionCount: import_zod3.z.number().int().nonnegative(),
+  approvalCount: import_zod3.z.number().int().nonnegative()
+});
+var RunStateSchema = import_zod3.z.object({
+  runId: import_zod3.z.string(),
+  workflowName: import_zod3.z.string(),
+  status: RunStatusSchema,
+  input: JsonValueSchema,
+  messages: import_zod3.z.array(RunMessageSchema),
+  agentCalls: import_zod3.z.array(AgentCallSchema),
+  toolCalls: import_zod3.z.array(ToolCallSchema),
+  policyDecisions: import_zod3.z.array(PolicyDecisionSchema),
+  routingDecisions: import_zod3.z.array(RoutingDecisionSchema),
+  approvals: import_zod3.z.array(RunApprovalSchema),
+  artifacts: import_zod3.z.array(RunArtifactSchema),
+  errors: import_zod3.z.array(RunErrorSchema),
+  metrics: RunMetricsSchema,
+  finalOutput: JsonValueSchema.nullable(),
+  createdAt: import_zod3.z.iso.datetime(),
+  startedAt: import_zod3.z.iso.datetime().nullable(),
+  completedAt: import_zod3.z.iso.datetime().nullable()
+});
+
+// src/trace-events.ts
+var TraceEventErrorSchema = import_zod4.z.object({
+  message: import_zod4.z.string(),
+  code: import_zod4.z.string().optional(),
+  stack: import_zod4.z.string().optional()
+});
+var TraceEventBaseSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  runId: import_zod4.z.string(),
+  workflowName: import_zod4.z.string(),
+  timestamp: import_zod4.z.iso.datetime(),
+  parentEventId: import_zod4.z.string().nullable(),
+  redacted: import_zod4.z.boolean(),
+  metadata: RunMetadataSchema.optional()
+});
+var RunStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("run.started"),
+  input: JsonValueSchema
+});
+var RunCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("run.completed"),
+  output: JsonValueSchema,
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var RunFailedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("run.failed"),
+  error: TraceEventErrorSchema,
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var AgentStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("agent.started"),
+  agentName: import_zod4.z.string(),
+  input: JsonValueSchema
+});
+var AgentCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("agent.completed"),
+  agentName: import_zod4.z.string(),
+  output: JsonValueSchema,
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var AgentFailedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("agent.failed"),
+  agentName: import_zod4.z.string(),
+  error: TraceEventErrorSchema,
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var ToolRequestedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("tool.requested"),
+  toolName: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  input: JsonValueSchema
+});
+var ToolApprovedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("tool.approved"),
+  toolName: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  approvalId: import_zod4.z.string().nullable()
+});
+var ToolBlockedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("tool.blocked"),
+  toolName: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  policyName: import_zod4.z.string(),
+  reason: import_zod4.z.string()
+});
+var ToolCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("tool.completed"),
+  toolName: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  output: JsonValueSchema,
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var ToolFailedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("tool.failed"),
+  toolName: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  error: TraceEventErrorSchema,
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var PolicyEvaluatedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("policy.evaluated"),
+  policyName: import_zod4.z.string(),
+  action: PolicyActionSchema,
+  agentName: import_zod4.z.string().optional(),
+  toolName: import_zod4.z.string().optional(),
+  reason: import_zod4.z.string()
+});
+var RouteSelectedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("route.selected"),
+  supervisorName: import_zod4.z.string(),
+  selectedAgentName: import_zod4.z.string(),
+  candidateAgentNames: import_zod4.z.array(import_zod4.z.string()),
+  reason: import_zod4.z.string()
+});
+var ApprovalRequiredEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("approval.required"),
+  approvalId: import_zod4.z.string(),
+  toolName: import_zod4.z.string().optional(),
+  agentName: import_zod4.z.string().optional(),
+  reason: import_zod4.z.string()
+});
+var ApprovalApprovedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("approval.approved"),
+  approvalId: import_zod4.z.string(),
+  decidedBy: import_zod4.z.string().nullable()
+});
+var ApprovalRejectedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("approval.rejected"),
+  approvalId: import_zod4.z.string(),
+  decidedBy: import_zod4.z.string().nullable(),
+  reason: import_zod4.z.string()
+});
+var EvalStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("eval.started"),
+  evalRunId: import_zod4.z.string(),
+  suiteName: import_zod4.z.string(),
+  caseCount: import_zod4.z.number().int().nonnegative()
+});
+var EvalCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("eval.completed"),
+  evalRunId: import_zod4.z.string(),
+  passedCaseCount: import_zod4.z.number().int().nonnegative(),
+  failedCaseCount: import_zod4.z.number().int().nonnegative(),
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var ReplayStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("replay.started"),
+  sourceRunId: import_zod4.z.string(),
+  fromEventId: import_zod4.z.string().nullable()
+});
+var ReplayCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod4.z.literal("replay.completed"),
+  sourceRunId: import_zod4.z.string(),
+  latencyMs: import_zod4.z.number().nonnegative()
+});
+var TraceEventSchema = import_zod4.z.discriminatedUnion("type", [
+  RunStartedEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  AgentStartedEventSchema,
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  ToolRequestedEventSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  PolicyEvaluatedEventSchema,
+  RouteSelectedEventSchema,
+  ApprovalRequiredEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  EvalStartedEventSchema,
+  EvalCompletedEventSchema,
+  ReplayStartedEventSchema,
+  ReplayCompletedEventSchema
+]);
+var traceEventTypes = TraceEventSchema.options.map(
+  (option) => option.shape.type.value
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  AgentStartedEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalRequiredEventSchema,
+  EvalCompletedEventSchema,
+  EvalStartedEventSchema,
+  PolicyEvaluatedEventSchema,
+  ReplayCompletedEventSchema,
+  ReplayStartedEventSchema,
+  RouteSelectedEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  RunStartedEventSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  ToolRequestedEventSchema,
+  TraceEventErrorSchema,
+  TraceEventSchema,
+  traceEventTypes
+});