@assemble-dev/shared-types 0.1.0

package/dist/errors.js

@@ -0,0 +1,6 @@
+import {
+  AppErrorCode
+} from "./chunk-L43XAKHI.js";
+export {
+  AppErrorCode
+};

package/dist/index.cjs

@@ -0,0 +1,467 @@
+"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, {
+  AgentCallSchema: () => AgentCallSchema,
+  AgentCallStatusSchema: () => AgentCallStatusSchema,
+  AgentCompletedEventSchema: () => AgentCompletedEventSchema,
+  AgentFailedEventSchema: () => AgentFailedEventSchema,
+  AgentStartedEventSchema: () => AgentStartedEventSchema,
+  ApiKeyEnvironmentSchema: () => ApiKeyEnvironmentSchema,
+  AppErrorCode: () => AppErrorCode,
+  ApprovalApprovedEventSchema: () => ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema: () => ApprovalRejectedEventSchema,
+  ApprovalRequiredEventSchema: () => ApprovalRequiredEventSchema,
+  ApprovalStatusSchema: () => ApprovalStatusSchema,
+  EvalCompletedEventSchema: () => EvalCompletedEventSchema,
+  EvalStartedEventSchema: () => EvalStartedEventSchema,
+  JsonObjectSchema: () => JsonObjectSchema,
+  JsonPrimitiveSchema: () => JsonPrimitiveSchema,
+  JsonValueSchema: () => JsonValueSchema,
+  PolicyActionSchema: () => PolicyActionSchema,
+  PolicyDecisionSchema: () => PolicyDecisionSchema,
+  PolicyEvaluatedEventSchema: () => PolicyEvaluatedEventSchema,
+  ReplayCompletedEventSchema: () => ReplayCompletedEventSchema,
+  ReplayStartedEventSchema: () => ReplayStartedEventSchema,
+  RouteSelectedEventSchema: () => RouteSelectedEventSchema,
+  RoutingDecisionSchema: () => RoutingDecisionSchema,
+  RunApprovalSchema: () => RunApprovalSchema,
+  RunArtifactSchema: () => RunArtifactSchema,
+  RunCompletedEventSchema: () => RunCompletedEventSchema,
+  RunErrorSchema: () => RunErrorSchema,
+  RunFailedEventSchema: () => RunFailedEventSchema,
+  RunMessageRoleSchema: () => RunMessageRoleSchema,
+  RunMessageSchema: () => RunMessageSchema,
+  RunMetadataSchema: () => RunMetadataSchema,
+  RunMetricsSchema: () => RunMetricsSchema,
+  RunStartedEventSchema: () => RunStartedEventSchema,
+  RunStateSchema: () => RunStateSchema,
+  RunStatusSchema: () => RunStatusSchema,
+  TokenUsageSchema: () => TokenUsageSchema,
+  ToolApprovedEventSchema: () => ToolApprovedEventSchema,
+  ToolBlockedEventSchema: () => ToolBlockedEventSchema,
+  ToolCallSchema: () => ToolCallSchema,
+  ToolCallStatusSchema: () => ToolCallStatusSchema,
+  ToolCompletedEventSchema: () => ToolCompletedEventSchema,
+  ToolFailedEventSchema: () => ToolFailedEventSchema,
+  ToolRequestedEventSchema: () => ToolRequestedEventSchema,
+  TraceEventErrorSchema: () => TraceEventErrorSchema,
+  TraceEventSchema: () => TraceEventSchema,
+  traceEventTypes: () => traceEventTypes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api-keys.ts
+var import_zod = require("zod");
+var ApiKeyEnvironmentSchema = import_zod.z.enum(["dev", "prod", "ci"]);
+
+// src/errors.ts
+var AppErrorCode = /* @__PURE__ */ ((AppErrorCode2) => {
+  AppErrorCode2["BadRequest"] = "BAD_REQUEST";
+  AppErrorCode2["Unauthorized"] = "UNAUTHORIZED";
+  AppErrorCode2["Forbidden"] = "FORBIDDEN";
+  AppErrorCode2["NotFound"] = "NOT_FOUND";
+  AppErrorCode2["Conflict"] = "CONFLICT";
+  AppErrorCode2["Canceled"] = "CANCELED";
+  AppErrorCode2["RateLimited"] = "RATE_LIMITED";
+  AppErrorCode2["CostBudgetExceeded"] = "COST_BUDGET_EXCEEDED";
+  AppErrorCode2["ValidationFailed"] = "VALIDATION_FAILED";
+  AppErrorCode2["UserAlreadyExists"] = "USER_ALREADY_EXISTS";
+  AppErrorCode2["WorkspaceNotFound"] = "WORKSPACE_NOT_FOUND";
+  AppErrorCode2["InternalServerError"] = "INTERNAL_SERVER_ERROR";
+  AppErrorCode2["ServiceUnavailable"] = "SERVICE_UNAVAILABLE";
+  return AppErrorCode2;
+})(AppErrorCode || {});
+
+// src/json.ts
+var import_zod2 = require("zod");
+var JsonPrimitiveSchema = import_zod2.z.union([
+  import_zod2.z.string(),
+  import_zod2.z.number(),
+  import_zod2.z.boolean(),
+  import_zod2.z.null()
+]);
+var JsonValueSchema = import_zod2.z.lazy(
+  () => import_zod2.z.union([
+    JsonPrimitiveSchema,
+    import_zod2.z.array(JsonValueSchema),
+    import_zod2.z.record(import_zod2.z.string(), JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = import_zod2.z.record(import_zod2.z.string(), JsonValueSchema);
+
+// src/run-metadata.ts
+var import_zod3 = require("zod");
+var RunMetadataSchema = import_zod3.z.object({
+  sessionId: import_zod3.z.string().optional(),
+  userId: import_zod3.z.string().optional(),
+  tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+  parentTraceId: import_zod3.z.string().optional(),
+  parentSpanId: import_zod3.z.string().optional()
+});
+
+// src/runs.ts
+var import_zod4 = require("zod");
+var RunStatusSchema = import_zod4.z.enum([
+  "pending",
+  "running",
+  "awaiting_approval",
+  "completed",
+  "failed",
+  "canceled",
+  "rejected"
+]);
+var PolicyActionSchema = import_zod4.z.enum([
+  "allow",
+  "block",
+  "requireApproval",
+  "logOnly",
+  "redact"
+]);
+var ApprovalStatusSchema = import_zod4.z.enum(["pending", "approved", "rejected"]);
+var RunErrorSchema = import_zod4.z.object({
+  message: import_zod4.z.string(),
+  code: import_zod4.z.string().optional(),
+  agentName: import_zod4.z.string().optional(),
+  toolName: import_zod4.z.string().optional(),
+  timestamp: import_zod4.z.iso.datetime()
+});
+var RunMessageRoleSchema = import_zod4.z.enum([
+  "system",
+  "user",
+  "assistant",
+  "tool"
+]);
+var RunMessageSchema = import_zod4.z.object({
+  role: RunMessageRoleSchema,
+  content: import_zod4.z.string(),
+  agentName: import_zod4.z.string().optional(),
+  toolName: import_zod4.z.string().optional(),
+  timestamp: import_zod4.z.iso.datetime()
+});
+var AgentCallStatusSchema = import_zod4.z.enum(["running", "completed", "failed"]);
+var AgentCallSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  status: AgentCallStatusSchema,
+  input: JsonValueSchema,
+  output: JsonValueSchema.nullable(),
+  error: RunErrorSchema.nullable(),
+  startedAt: import_zod4.z.iso.datetime(),
+  completedAt: import_zod4.z.iso.datetime().nullable(),
+  latencyMs: import_zod4.z.number().nonnegative().nullable()
+});
+var ToolCallStatusSchema = import_zod4.z.enum([
+  "requested",
+  "approved",
+  "blocked",
+  "completed",
+  "failed"
+]);
+var ToolCallSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  toolName: import_zod4.z.string(),
+  agentName: import_zod4.z.string(),
+  status: ToolCallStatusSchema,
+  input: JsonValueSchema,
+  output: JsonValueSchema.nullable(),
+  error: RunErrorSchema.nullable(),
+  requestedAt: import_zod4.z.iso.datetime(),
+  completedAt: import_zod4.z.iso.datetime().nullable(),
+  latencyMs: import_zod4.z.number().nonnegative().nullable()
+});
+var PolicyDecisionSchema = import_zod4.z.object({
+  policyName: import_zod4.z.string(),
+  action: PolicyActionSchema,
+  agentName: import_zod4.z.string().optional(),
+  toolName: import_zod4.z.string().optional(),
+  reason: import_zod4.z.string(),
+  timestamp: import_zod4.z.iso.datetime()
+});
+var RoutingDecisionSchema = import_zod4.z.object({
+  supervisorName: import_zod4.z.string(),
+  selectedAgentName: import_zod4.z.string(),
+  candidateAgentNames: import_zod4.z.array(import_zod4.z.string()),
+  reason: import_zod4.z.string(),
+  timestamp: import_zod4.z.iso.datetime()
+});
+var RunApprovalSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  status: ApprovalStatusSchema,
+  toolCallId: import_zod4.z.string().nullable(),
+  toolName: import_zod4.z.string().optional(),
+  agentName: import_zod4.z.string().optional(),
+  reason: import_zod4.z.string(),
+  requestedAt: import_zod4.z.iso.datetime(),
+  decidedAt: import_zod4.z.iso.datetime().nullable(),
+  decidedBy: import_zod4.z.string().nullable()
+});
+var RunArtifactSchema = import_zod4.z.object({
+  key: import_zod4.z.string(),
+  value: JsonValueSchema,
+  producedByAgentName: import_zod4.z.string().optional(),
+  createdAt: import_zod4.z.iso.datetime()
+});
+var TokenUsageSchema = import_zod4.z.object({
+  inputTokens: import_zod4.z.number().int().nonnegative(),
+  outputTokens: import_zod4.z.number().int().nonnegative(),
+  totalTokens: import_zod4.z.number().int().nonnegative(),
+  cacheCreationInputTokens: import_zod4.z.number().int().nonnegative().optional(),
+  cacheReadInputTokens: import_zod4.z.number().int().nonnegative().optional()
+});
+var RunMetricsSchema = import_zod4.z.object({
+  totalLatencyMs: import_zod4.z.number().nonnegative().nullable(),
+  tokenUsage: TokenUsageSchema.nullable(),
+  agentCallCount: import_zod4.z.number().int().nonnegative(),
+  toolCallCount: import_zod4.z.number().int().nonnegative(),
+  policyDecisionCount: import_zod4.z.number().int().nonnegative(),
+  approvalCount: import_zod4.z.number().int().nonnegative()
+});
+var RunStateSchema = import_zod4.z.object({
+  runId: import_zod4.z.string(),
+  workflowName: import_zod4.z.string(),
+  status: RunStatusSchema,
+  input: JsonValueSchema,
+  messages: import_zod4.z.array(RunMessageSchema),
+  agentCalls: import_zod4.z.array(AgentCallSchema),
+  toolCalls: import_zod4.z.array(ToolCallSchema),
+  policyDecisions: import_zod4.z.array(PolicyDecisionSchema),
+  routingDecisions: import_zod4.z.array(RoutingDecisionSchema),
+  approvals: import_zod4.z.array(RunApprovalSchema),
+  artifacts: import_zod4.z.array(RunArtifactSchema),
+  errors: import_zod4.z.array(RunErrorSchema),
+  metrics: RunMetricsSchema,
+  finalOutput: JsonValueSchema.nullable(),
+  createdAt: import_zod4.z.iso.datetime(),
+  startedAt: import_zod4.z.iso.datetime().nullable(),
+  completedAt: import_zod4.z.iso.datetime().nullable()
+});
+
+// src/trace-events.ts
+var import_zod5 = require("zod");
+var TraceEventErrorSchema = import_zod5.z.object({
+  message: import_zod5.z.string(),
+  code: import_zod5.z.string().optional(),
+  stack: import_zod5.z.string().optional()
+});
+var TraceEventBaseSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  runId: import_zod5.z.string(),
+  workflowName: import_zod5.z.string(),
+  timestamp: import_zod5.z.iso.datetime(),
+  parentEventId: import_zod5.z.string().nullable(),
+  redacted: import_zod5.z.boolean(),
+  metadata: RunMetadataSchema.optional()
+});
+var RunStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("run.started"),
+  input: JsonValueSchema
+});
+var RunCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("run.completed"),
+  output: JsonValueSchema,
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var RunFailedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("run.failed"),
+  error: TraceEventErrorSchema,
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var AgentStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("agent.started"),
+  agentName: import_zod5.z.string(),
+  input: JsonValueSchema
+});
+var AgentCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("agent.completed"),
+  agentName: import_zod5.z.string(),
+  output: JsonValueSchema,
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var AgentFailedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("agent.failed"),
+  agentName: import_zod5.z.string(),
+  error: TraceEventErrorSchema,
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var ToolRequestedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("tool.requested"),
+  toolName: import_zod5.z.string(),
+  agentName: import_zod5.z.string(),
+  input: JsonValueSchema
+});
+var ToolApprovedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("tool.approved"),
+  toolName: import_zod5.z.string(),
+  agentName: import_zod5.z.string(),
+  approvalId: import_zod5.z.string().nullable()
+});
+var ToolBlockedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("tool.blocked"),
+  toolName: import_zod5.z.string(),
+  agentName: import_zod5.z.string(),
+  policyName: import_zod5.z.string(),
+  reason: import_zod5.z.string()
+});
+var ToolCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("tool.completed"),
+  toolName: import_zod5.z.string(),
+  agentName: import_zod5.z.string(),
+  output: JsonValueSchema,
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var ToolFailedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("tool.failed"),
+  toolName: import_zod5.z.string(),
+  agentName: import_zod5.z.string(),
+  error: TraceEventErrorSchema,
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var PolicyEvaluatedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("policy.evaluated"),
+  policyName: import_zod5.z.string(),
+  action: PolicyActionSchema,
+  agentName: import_zod5.z.string().optional(),
+  toolName: import_zod5.z.string().optional(),
+  reason: import_zod5.z.string()
+});
+var RouteSelectedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("route.selected"),
+  supervisorName: import_zod5.z.string(),
+  selectedAgentName: import_zod5.z.string(),
+  candidateAgentNames: import_zod5.z.array(import_zod5.z.string()),
+  reason: import_zod5.z.string()
+});
+var ApprovalRequiredEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("approval.required"),
+  approvalId: import_zod5.z.string(),
+  toolName: import_zod5.z.string().optional(),
+  agentName: import_zod5.z.string().optional(),
+  reason: import_zod5.z.string()
+});
+var ApprovalApprovedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("approval.approved"),
+  approvalId: import_zod5.z.string(),
+  decidedBy: import_zod5.z.string().nullable()
+});
+var ApprovalRejectedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("approval.rejected"),
+  approvalId: import_zod5.z.string(),
+  decidedBy: import_zod5.z.string().nullable(),
+  reason: import_zod5.z.string()
+});
+var EvalStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("eval.started"),
+  evalRunId: import_zod5.z.string(),
+  suiteName: import_zod5.z.string(),
+  caseCount: import_zod5.z.number().int().nonnegative()
+});
+var EvalCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("eval.completed"),
+  evalRunId: import_zod5.z.string(),
+  passedCaseCount: import_zod5.z.number().int().nonnegative(),
+  failedCaseCount: import_zod5.z.number().int().nonnegative(),
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var ReplayStartedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("replay.started"),
+  sourceRunId: import_zod5.z.string(),
+  fromEventId: import_zod5.z.string().nullable()
+});
+var ReplayCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: import_zod5.z.literal("replay.completed"),
+  sourceRunId: import_zod5.z.string(),
+  latencyMs: import_zod5.z.number().nonnegative()
+});
+var TraceEventSchema = import_zod5.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 = {
+  AgentCallSchema,
+  AgentCallStatusSchema,
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  AgentStartedEventSchema,
+  ApiKeyEnvironmentSchema,
+  AppErrorCode,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalRequiredEventSchema,
+  ApprovalStatusSchema,
+  EvalCompletedEventSchema,
+  EvalStartedEventSchema,
+  JsonObjectSchema,
+  JsonPrimitiveSchema,
+  JsonValueSchema,
+  PolicyActionSchema,
+  PolicyDecisionSchema,
+  PolicyEvaluatedEventSchema,
+  ReplayCompletedEventSchema,
+  ReplayStartedEventSchema,
+  RouteSelectedEventSchema,
+  RoutingDecisionSchema,
+  RunApprovalSchema,
+  RunArtifactSchema,
+  RunCompletedEventSchema,
+  RunErrorSchema,
+  RunFailedEventSchema,
+  RunMessageRoleSchema,
+  RunMessageSchema,
+  RunMetadataSchema,
+  RunMetricsSchema,
+  RunStartedEventSchema,
+  RunStateSchema,
+  RunStatusSchema,
+  TokenUsageSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCallSchema,
+  ToolCallStatusSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  ToolRequestedEventSchema,
+  TraceEventErrorSchema,
+  TraceEventSchema,
+  traceEventTypes
+});

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+export { ApiKeyEnvironment, ApiKeyEnvironmentSchema } from './api-keys.cjs';
+export { AppErrorCode, AppErrorDetails, AppErrorInput, AppErrorResponse } from './errors.cjs';
+export { JsonObject, JsonObjectSchema, JsonPrimitive, JsonPrimitiveSchema, JsonValue, JsonValueSchema } from './json.cjs';
+export { RunMetadata, RunMetadataSchema } from './run-metadata.cjs';
+export { AgentCall, AgentCallSchema, AgentCallStatus, AgentCallStatusSchema, ApprovalStatus, ApprovalStatusSchema, PolicyAction, PolicyActionSchema, PolicyDecision, PolicyDecisionSchema, RoutingDecision, RoutingDecisionSchema, RunApproval, RunApprovalSchema, RunArtifact, RunArtifactSchema, RunError, RunErrorSchema, RunMessage, RunMessageRole, RunMessageRoleSchema, RunMessageSchema, RunMetrics, RunMetricsSchema, RunState, RunStateSchema, RunStatus, RunStatusSchema, TokenUsage, TokenUsageSchema, ToolCall, ToolCallSchema, ToolCallStatus, ToolCallStatusSchema } from './runs.cjs';
+export { AgentCompletedEvent, AgentCompletedEventSchema, AgentFailedEvent, AgentFailedEventSchema, AgentStartedEvent, AgentStartedEventSchema, ApprovalApprovedEvent, ApprovalApprovedEventSchema, ApprovalRejectedEvent, ApprovalRejectedEventSchema, ApprovalRequiredEvent, ApprovalRequiredEventSchema, EvalCompletedEvent, EvalCompletedEventSchema, EvalStartedEvent, EvalStartedEventSchema, PolicyEvaluatedEvent, PolicyEvaluatedEventSchema, ReplayCompletedEvent, ReplayCompletedEventSchema, ReplayStartedEvent, ReplayStartedEventSchema, RouteSelectedEvent, RouteSelectedEventSchema, RunCompletedEvent, RunCompletedEventSchema, RunFailedEvent, RunFailedEventSchema, RunStartedEvent, RunStartedEventSchema, ToolApprovedEvent, ToolApprovedEventSchema, ToolBlockedEvent, ToolBlockedEventSchema, ToolCompletedEvent, ToolCompletedEventSchema, ToolFailedEvent, ToolFailedEventSchema, ToolRequestedEvent, ToolRequestedEventSchema, TraceEvent, TraceEventError, TraceEventErrorSchema, TraceEventSchema, TraceEventType, traceEventTypes } from './trace-events.cjs';
+export { SchemaValidationFailure, SchemaValidationIssue, SchemaValidationResult, SchemaValidationSuccess, ValidationSchema } from './validation.cjs';
+import 'zod';

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { ApiKeyEnvironment, ApiKeyEnvironmentSchema } from './api-keys.js';
+export { AppErrorCode, AppErrorDetails, AppErrorInput, AppErrorResponse } from './errors.js';
+export { JsonObject, JsonObjectSchema, JsonPrimitive, JsonPrimitiveSchema, JsonValue, JsonValueSchema } from './json.js';
+export { RunMetadata, RunMetadataSchema } from './run-metadata.js';
+export { AgentCall, AgentCallSchema, AgentCallStatus, AgentCallStatusSchema, ApprovalStatus, ApprovalStatusSchema, PolicyAction, PolicyActionSchema, PolicyDecision, PolicyDecisionSchema, RoutingDecision, RoutingDecisionSchema, RunApproval, RunApprovalSchema, RunArtifact, RunArtifactSchema, RunError, RunErrorSchema, RunMessage, RunMessageRole, RunMessageRoleSchema, RunMessageSchema, RunMetrics, RunMetricsSchema, RunState, RunStateSchema, RunStatus, RunStatusSchema, TokenUsage, TokenUsageSchema, ToolCall, ToolCallSchema, ToolCallStatus, ToolCallStatusSchema } from './runs.js';
+export { AgentCompletedEvent, AgentCompletedEventSchema, AgentFailedEvent, AgentFailedEventSchema, AgentStartedEvent, AgentStartedEventSchema, ApprovalApprovedEvent, ApprovalApprovedEventSchema, ApprovalRejectedEvent, ApprovalRejectedEventSchema, ApprovalRequiredEvent, ApprovalRequiredEventSchema, EvalCompletedEvent, EvalCompletedEventSchema, EvalStartedEvent, EvalStartedEventSchema, PolicyEvaluatedEvent, PolicyEvaluatedEventSchema, ReplayCompletedEvent, ReplayCompletedEventSchema, ReplayStartedEvent, ReplayStartedEventSchema, RouteSelectedEvent, RouteSelectedEventSchema, RunCompletedEvent, RunCompletedEventSchema, RunFailedEvent, RunFailedEventSchema, RunStartedEvent, RunStartedEventSchema, ToolApprovedEvent, ToolApprovedEventSchema, ToolBlockedEvent, ToolBlockedEventSchema, ToolCompletedEvent, ToolCompletedEventSchema, ToolFailedEvent, ToolFailedEventSchema, ToolRequestedEvent, ToolRequestedEventSchema, TraceEvent, TraceEventError, TraceEventErrorSchema, TraceEventSchema, TraceEventType, traceEventTypes } from './trace-events.js';
+export { SchemaValidationFailure, SchemaValidationIssue, SchemaValidationResult, SchemaValidationSuccess, ValidationSchema } from './validation.js';
+import 'zod';

package/dist/index.js

@@ -0,0 +1,107 @@
+import {
+  ApiKeyEnvironmentSchema
+} from "./chunk-Z3WAEROF.js";
+import {
+  AppErrorCode
+} from "./chunk-L43XAKHI.js";
+import {
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  AgentStartedEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalRequiredEventSchema,
+  EvalCompletedEventSchema,
+  EvalStartedEventSchema,
+  PolicyEvaluatedEventSchema,
+  ReplayCompletedEventSchema,
+  ReplayStartedEventSchema,
+  RouteSelectedEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  RunStartedEventSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  ToolRequestedEventSchema,
+  TraceEventErrorSchema,
+  TraceEventSchema,
+  traceEventTypes
+} from "./chunk-PQRNSB4E.js";
+import {
+  RunMetadataSchema
+} from "./chunk-F5XOAPYA.js";
+import {
+  AgentCallSchema,
+  AgentCallStatusSchema,
+  ApprovalStatusSchema,
+  PolicyActionSchema,
+  PolicyDecisionSchema,
+  RoutingDecisionSchema,
+  RunApprovalSchema,
+  RunArtifactSchema,
+  RunErrorSchema,
+  RunMessageRoleSchema,
+  RunMessageSchema,
+  RunMetricsSchema,
+  RunStateSchema,
+  RunStatusSchema,
+  TokenUsageSchema,
+  ToolCallSchema,
+  ToolCallStatusSchema
+} from "./chunk-WTIOTJHP.js";
+import {
+  JsonObjectSchema,
+  JsonPrimitiveSchema,
+  JsonValueSchema
+} from "./chunk-4FCV35HE.js";
+import "./chunk-MDGGODHM.js";
+export {
+  AgentCallSchema,
+  AgentCallStatusSchema,
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  AgentStartedEventSchema,
+  ApiKeyEnvironmentSchema,
+  AppErrorCode,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  ApprovalRequiredEventSchema,
+  ApprovalStatusSchema,
+  EvalCompletedEventSchema,
+  EvalStartedEventSchema,
+  JsonObjectSchema,
+  JsonPrimitiveSchema,
+  JsonValueSchema,
+  PolicyActionSchema,
+  PolicyDecisionSchema,
+  PolicyEvaluatedEventSchema,
+  ReplayCompletedEventSchema,
+  ReplayStartedEventSchema,
+  RouteSelectedEventSchema,
+  RoutingDecisionSchema,
+  RunApprovalSchema,
+  RunArtifactSchema,
+  RunCompletedEventSchema,
+  RunErrorSchema,
+  RunFailedEventSchema,
+  RunMessageRoleSchema,
+  RunMessageSchema,
+  RunMetadataSchema,
+  RunMetricsSchema,
+  RunStartedEventSchema,
+  RunStateSchema,
+  RunStatusSchema,
+  TokenUsageSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCallSchema,
+  ToolCallStatusSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  ToolRequestedEventSchema,
+  TraceEventErrorSchema,
+  TraceEventSchema,
+  traceEventTypes
+};

package/dist/json.cjs

@@ -0,0 +1,48 @@
+"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/json.ts
+var json_exports = {};
+__export(json_exports, {
+  JsonObjectSchema: () => JsonObjectSchema,
+  JsonPrimitiveSchema: () => JsonPrimitiveSchema,
+  JsonValueSchema: () => JsonValueSchema
+});
+module.exports = __toCommonJS(json_exports);
+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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonObjectSchema,
+  JsonPrimitiveSchema,
+  JsonValueSchema
+});

package/dist/json.d.cts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+declare const JsonPrimitiveSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+type JsonPrimitive = z.infer<typeof JsonPrimitiveSchema>;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+declare const JsonValueSchema: z.ZodType<JsonValue>;
+declare const JsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+type JsonObject = z.infer<typeof JsonObjectSchema>;
+
+export { type JsonObject, JsonObjectSchema, type JsonPrimitive, JsonPrimitiveSchema, type JsonValue, JsonValueSchema };

package/dist/json.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+declare const JsonPrimitiveSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+type JsonPrimitive = z.infer<typeof JsonPrimitiveSchema>;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+declare const JsonValueSchema: z.ZodType<JsonValue>;
+declare const JsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+type JsonObject = z.infer<typeof JsonObjectSchema>;
+
+export { type JsonObject, JsonObjectSchema, type JsonPrimitive, JsonPrimitiveSchema, type JsonValue, JsonValueSchema };

package/dist/json.js

@@ -0,0 +1,10 @@
+import {
+  JsonObjectSchema,
+  JsonPrimitiveSchema,
+  JsonValueSchema
+} from "./chunk-4FCV35HE.js";
+export {
+  JsonObjectSchema,
+  JsonPrimitiveSchema,
+  JsonValueSchema
+};