@kortyx/telemetry-contracts 0.1.0 → 0.3.0

package/dist/index.js

@@ -21,16 +21,164 @@ var index_exports = {};
 __export(index_exports, {
   EnsureWorkflowTopologyRequestSchema: () => EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema: () => EnsureWorkflowTopologyResponseSchema,
+  STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
+  StudioCatalogsResponseSchema: () => StudioCatalogsResponseSchema,
+  StudioChangeResourceSchema: () => StudioChangeResourceSchema,
+  StudioChangeSchema: () => StudioChangeSchema,
+  StudioContextResponseSchema: () => StudioContextResponseSchema,
+  StudioDetailEventSchema: () => StudioDetailEventSchema,
+  StudioInterruptDetailResponseSchema: () => StudioInterruptDetailResponseSchema,
+  StudioInterruptInteractionModeSchema: () => StudioInterruptInteractionModeSchema,
+  StudioInterruptOptionSchema: () => StudioInterruptOptionSchema,
+  StudioInterruptSchema: () => StudioInterruptSchema,
+  StudioInterruptStatusSchema: () => StudioInterruptStatusSchema,
+  StudioInterruptTypeSchema: () => StudioInterruptTypeSchema,
+  StudioInterruptsResponseSchema: () => StudioInterruptsResponseSchema,
+  StudioMetricSchema: () => StudioMetricSchema,
+  StudioPricingSourceSchema: () => StudioPricingSourceSchema,
+  StudioPricingStatusSchema: () => StudioPricingStatusSchema,
+  StudioResumeOutcomeSchema: () => StudioResumeOutcomeSchema,
+  StudioRunDetailResponseSchema: () => StudioRunDetailResponseSchema,
+  StudioRunSchema: () => StudioRunSchema,
+  StudioRunStatusSchema: () => StudioRunStatusSchema,
+  StudioRunsResponseSchema: () => StudioRunsResponseSchema,
+  StudioSessionDetailResponseSchema: () => StudioSessionDetailResponseSchema,
+  StudioSessionSchema: () => StudioSessionSchema,
+  StudioSessionsResponseSchema: () => StudioSessionsResponseSchema,
+  StudioTimeRangeContextSchema: () => StudioTimeRangeContextSchema,
+  StudioTimeRangeQuerySchema: () => StudioTimeRangeQuerySchema,
+  StudioTimeRangeSchema: () => StudioTimeRangeSchema,
+  StudioWorkflowHealthSchema: () => StudioWorkflowHealthSchema,
+  StudioWorkflowInternalEdgeSchema: () => StudioWorkflowInternalEdgeSchema,
+  StudioWorkflowNodeSchema: () => StudioWorkflowNodeSchema,
+  StudioWorkflowSchema: () => StudioWorkflowSchema,
+  StudioWorkflowTransitionSchema: () => StudioWorkflowTransitionSchema,
+  StudioWorkflowsResponseSchema: () => StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES: () => TELEMETRY_EVENT_TYPES,
+  TelemetryEventBatchResponseSchema: () => TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema: () => TelemetryEventBatchSchema,
   TelemetryEventSchema: () => TelemetryEventSchema,
   TelemetryEventTypeSchema: () => TelemetryEventTypeSchema,
+  TelemetryPricingHintSchema: () => TelemetryPricingHintSchema,
+  TelemetryPricingLineItemSchema: () => TelemetryPricingLineItemSchema,
+  TelemetryPricingSourceSchema: () => TelemetryPricingSourceSchema,
+  TelemetryPricingUnitSchema: () => TelemetryPricingUnitSchema,
+  TelemetryPricingUsageTypeSchema: () => TelemetryPricingUsageTypeSchema,
   TelemetryServiceSchema: () => TelemetryServiceSchema,
+  TelemetryUnitPriceSchema: () => TelemetryUnitPriceSchema,
+  TelemetryUsageItemSchema: () => TelemetryUsageItemSchema,
+  WorkflowTopologyCallSchema: () => WorkflowTopologyCallSchema,
   WorkflowTopologyEdgeSchema: () => WorkflowTopologyEdgeSchema,
-  WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema
+  WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema,
+  WorkflowTopologyTransitionSchema: () => WorkflowTopologyTransitionSchema,
+  projectWorkflowCalls: () => projectWorkflowCalls,
+  resolveStudioInterruptStatus: () => resolveStudioInterruptStatus,
+  resolveStudioTimeRange: () => resolveStudioTimeRange
 });
 module.exports = __toCommonJS(index_exports);
 var import_zod = require("zod");
+
+// src/workflow-calls.ts
+var str = (v, fallback = "") => typeof v === "string" ? v : fallback;
+function projectWorkflowCalls(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!event.type.startsWith("workflow.call.") || !str(event.payload.invocationId) || !str(event.payload.targetWorkflowId))
+      continue;
+    const key = `${event.runId}:${str(event.payload.branchId, event.runId)}:${event.payload.invocationId}`;
+    const group = groups.get(key) ?? [];
+    if (!group.some((existing) => existing.id === event.id)) group.push(event);
+    groups.set(key, group);
+  }
+  return [...groups.entries()].map(([id, group]) => {
+    group.sort(
+      (a, b) => Number(a.payload.sequence ?? 0) - Number(b.payload.sequence ?? 0) || a.occurredAt.localeCompare(b.occurredAt) || a.id.localeCompare(b.id)
+    );
+    const first = group[0];
+    const p = first.payload;
+    const call = {
+      id,
+      invocationId: str(p.invocationId),
+      branchId: str(p.branchId, first.runId),
+      parentInvocationId: str(p.parentInvocationId) || null,
+      callId: str(p.callId),
+      callerNodeId: str(p.callerNodeId),
+      callerNodeExecutionId: str(p.callerNodeExecutionId),
+      sourceWorkflowId: str(p.sourceWorkflowId, first.workflowId),
+      targetWorkflowId: str(p.targetWorkflowId),
+      targetVersion: str(p.targetVersion) || null,
+      status: "incomplete",
+      startedAt: first.occurredAt,
+      endedAt: null,
+      activeMs: 0,
+      waitMs: 0,
+      attempts: 0,
+      reused: 0,
+      inherited: false,
+      sourceRunId: null,
+      leaf: null,
+      events: group
+    };
+    let active = null;
+    let waiting = null;
+    for (const event of group) {
+      const at = Date.parse(event.occurredAt);
+      const status = event.type.slice("workflow.call.".length);
+      for (const side of [
+        "input",
+        "output",
+        "inputOmitted",
+        "outputOmitted"
+      ])
+        if (side in event.payload) call[side] = event.payload[side];
+      if (status === "restored") {
+        call.inherited = true;
+        call.sourceRunId = str(event.payload.sourceRunId) || null;
+        call.status = event.payload.status === "completed" ? "completed" : event.payload.status === "failed" ? "failed" : "interrupted";
+        if (call.status === "interrupted") waiting = at;
+      } else if (status === "started" || status === "resumed") {
+        if (waiting !== null) call.waitMs += Math.max(0, at - waiting);
+        waiting = null;
+        active = at;
+        call.attempts++;
+        call.status = "running";
+        call.endedAt = null;
+      } else if (status === "reused") {
+        call.reused++;
+        call.status = "completed";
+      } else if (status === "suspended" || status === "completed" || status === "failed") {
+        if (active !== null) call.activeMs += Math.max(0, at - active);
+        active = null;
+        call.status = status === "suspended" ? "interrupted" : status;
+        if (status === "suspended") {
+          waiting = at;
+          const leaf = event.payload.leaf;
+          if (leaf && typeof leaf === "object") {
+            const value = leaf;
+            call.leaf = {
+              workflowId: str(value.workflowId),
+              nodeId: str(value.nodeId),
+              invocationId: str(value.invocationId)
+            };
+          }
+        } else {
+          call.endedAt = event.occurredAt;
+          call.leaf = null;
+        }
+      }
+    }
+    const cancellation = events.find(
+      (event) => event.type === "run.cancelled" && event.runId === first.runId && (event.payload.branchId ?? event.runId) === call.branchId && event.occurredAt >= (group.at(-1)?.occurredAt ?? first.occurredAt)
+    );
+    if (cancellation && (call.status === "interrupted" || call.status === "running")) {
+      call.status = "cancelled";
+      call.endedAt = cancellation.occurredAt;
+    }
+    return call;
+  }).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+
+// src/index.ts
 var TELEMETRY_EVENT_TYPES = [
   "span.started",
   "span.ended",
@@ -45,6 +193,13 @@ var TELEMETRY_EVENT_TYPES = [
   "interrupt.cancelled",
   "run.cancelled",
   "workflow.transitioned",
+  "workflow.call.started",
+  "workflow.call.suspended",
+  "workflow.call.resumed",
+  "workflow.call.completed",
+  "workflow.call.failed",
+  "workflow.call.reused",
+  "workflow.call.restored",
   "session.checkpointed",
   "session.forked",
   "session.rolled_back"
@@ -66,6 +221,17 @@ var WorkflowTopologyEdgeSchema = import_zod.z.object({
   targetNodeId: import_zod.z.string().min(1),
   condition: import_zod.z.string().optional()
 }).strict();
+var WorkflowTopologyCallSchema = import_zod.z.object({
+  sourceNodeId: import_zod.z.string().min(1),
+  targetWorkflowId: import_zod.z.string().min(1)
+}).strict();
+var WorkflowTopologyTransitionSchema = import_zod.z.object({
+  sourceNodeId: import_zod.z.string().min(1).optional(),
+  targetWorkflowId: import_zod.z.string().min(1),
+  condition: import_zod.z.string().optional(),
+  intent: import_zod.z.string().optional(),
+  kind: import_zod.z.enum(["call", "handoff"]).optional()
+}).strict();
 var EnsureWorkflowTopologyRequestSchema = import_zod.z.object({
   schemaVersion: import_zod.z.literal(1),
   environment: import_zod.z.string().min(1),
@@ -77,7 +243,9 @@ var EnsureWorkflowTopologyRequestSchema = import_zod.z.object({
     tags: import_zod.z.array(import_zod.z.string()).optional(),
     topologyHash: import_zod.z.string().regex(/^[a-f0-9]{64}$/),
     nodes: import_zod.z.array(WorkflowTopologyNodeSchema),
-    edges: import_zod.z.array(WorkflowTopologyEdgeSchema)
+    edges: import_zod.z.array(WorkflowTopologyEdgeSchema),
+    transitions: import_zod.z.array(WorkflowTopologyTransitionSchema).optional(),
+    calls: import_zod.z.array(WorkflowTopologyCallSchema).optional()
   }).strict()
 }).strict();
 var EnsureWorkflowTopologyResponseSchema = import_zod.z.object({ workflowRevisionId: import_zod.z.string().min(1), created: import_zod.z.boolean() }).strict();
@@ -89,6 +257,9 @@ var TelemetryEventSchema = import_zod.z.object({
   environment: import_zod.z.string().min(1),
   service: TelemetryServiceSchema,
   correlation: import_zod.z.object({
+    invocationId: import_zod.z.string().optional(),
+    parentInvocationId: import_zod.z.string().optional(),
+    branchId: import_zod.z.string().optional(),
     traceId: import_zod.z.string().optional(),
     spanId: import_zod.z.string().optional(),
     parentSpanId: import_zod.z.string().optional(),
@@ -109,16 +280,552 @@ var TelemetryEventSchema = import_zod.z.object({
   payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
 }).strict();
 var TelemetryEventBatchSchema = import_zod.z.object({ events: import_zod.z.array(TelemetryEventSchema).min(1) }).strict();
+var TelemetryEventBatchResponseSchema = import_zod.z.object({
+  accepted: import_zod.z.number().int().nonnegative(),
+  inserted: import_zod.z.number().int().nonnegative(),
+  duplicates: import_zod.z.number().int().nonnegative()
+}).strict();
+var TelemetryPricingSourceSchema = import_zod.z.enum([
+  "sdk",
+  "provider",
+  "custom",
+  "project-rate-card",
+  "default-rate-card"
+]);
+var TelemetryPricingUnitSchema = import_zod.z.enum([
+  "token",
+  "character",
+  "request",
+  "image",
+  "audio_second",
+  "audio_minute",
+  "video_second",
+  "video_minute",
+  "second",
+  "minute",
+  "custom"
+]);
+var TelemetryPricingUsageTypeSchema = import_zod.z.enum([
+  "input",
+  "output",
+  "reasoning",
+  "cache_read",
+  "cache_write",
+  "embedding",
+  "image_input",
+  "image_output",
+  "audio_input",
+  "audio_output",
+  "video_input",
+  "video_output",
+  "request",
+  "custom"
+]);
+var TelemetryUsageItemSchema = import_zod.z.object({
+  usageType: TelemetryPricingUsageTypeSchema,
+  quantity: import_zod.z.number().nonnegative(),
+  unit: TelemetryPricingUnitSchema,
+  label: import_zod.z.string().optional()
+}).strict();
+var TelemetryUnitPriceSchema = import_zod.z.object({
+  usageType: TelemetryPricingUsageTypeSchema,
+  unit: TelemetryPricingUnitSchema,
+  unitQuantity: import_zod.z.number().positive().default(1),
+  priceMicros: import_zod.z.number().int().nonnegative(),
+  label: import_zod.z.string().optional()
+}).strict();
+var TelemetryPricingLineItemSchema = import_zod.z.object({
+  usageType: TelemetryPricingUsageTypeSchema,
+  quantity: import_zod.z.number().nonnegative(),
+  unit: TelemetryPricingUnitSchema,
+  unitQuantity: import_zod.z.number().positive().default(1),
+  unitPriceMicros: import_zod.z.number().int().nonnegative().optional(),
+  totalCostMicros: import_zod.z.number().int().nonnegative().optional(),
+  label: import_zod.z.string().optional()
+}).strict().refine(
+  (value) => value.totalCostMicros !== void 0 || value.unitPriceMicros !== void 0,
+  "line item requires totalCostMicros or unitPriceMicros"
+);
+var TelemetryPricingHintSchema = import_zod.z.object({
+  source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
+  currency: import_zod.z.string().min(3).max(12).default("USD"),
+  actualCostMicros: import_zod.z.number().int().nonnegative().optional(),
+  lineItems: import_zod.z.array(TelemetryPricingLineItemSchema).optional(),
+  unitPrices: import_zod.z.array(TelemetryUnitPriceSchema).optional(),
+  usageItems: import_zod.z.array(TelemetryUsageItemSchema).optional(),
+  pricingRef: import_zod.z.string().min(1).optional(),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+}).strict();
+var StudioRunStatusSchema = import_zod.z.enum([
+  "running",
+  "completed",
+  "interrupted",
+  "incomplete",
+  "failed",
+  "cancelled"
+]);
+var STUDIO_TIME_RANGES = [
+  "Last hour",
+  "24 hours",
+  "7 days",
+  "30 days",
+  "All time",
+  "Custom range"
+];
+var StudioTimeRangeSchema = import_zod.z.enum(STUDIO_TIME_RANGES);
+var StudioTimeRangeQuerySchema = import_zod.z.object({
+  range: StudioTimeRangeSchema.optional(),
+  startedAfter: import_zod.z.string().optional(),
+  startedBefore: import_zod.z.string().optional()
+}).strict();
+var StudioTimeRangeContextSchema = import_zod.z.object({
+  range: StudioTimeRangeSchema,
+  startedAfter: import_zod.z.string().datetime({ offset: true }).nullable(),
+  startedBefore: import_zod.z.string().datetime({ offset: true }).nullable()
+}).strict();
+var STUDIO_TIME_RANGE_MILLISECONDS = {
+  "Last hour": 60 * 60 * 1e3,
+  "24 hours": 24 * 60 * 60 * 1e3,
+  "7 days": 7 * 24 * 60 * 60 * 1e3,
+  "30 days": 30 * 24 * 60 * 60 * 1e3
+};
+var parseIsoBoundary = (value, label) => {
+  if (!value) {
+    return { ok: false, error: `${label} is required for a custom range.` };
+  }
+  if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
+    return {
+      ok: false,
+      error: `${label} must include an explicit UTC offset.`
+    };
+  }
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? { ok: true, date } : { ok: false, error: `${label} must be a valid ISO date and time.` };
+};
+var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
+  const parsedRange = StudioTimeRangeSchema.safeParse(
+    input.range || "24 hours"
+  );
+  if (!parsedRange.success) {
+    return {
+      ok: false,
+      error: `Unknown time range "${input.range}".`
+    };
+  }
+  if (!Number.isFinite(now.getTime())) {
+    return { ok: false, error: "The time range reference date is invalid." };
+  }
+  const range = parsedRange.data;
+  if (range === "All time") {
+    return {
+      ok: true,
+      value: { range, startedAfter: null, startedBefore: null }
+    };
+  }
+  if (range === "Custom range") {
+    const after = parseIsoBoundary(input.startedAfter, "Start time");
+    if ("error" in after) return { ok: false, error: after.error };
+    const before = parseIsoBoundary(input.startedBefore, "End time");
+    if ("error" in before) return { ok: false, error: before.error };
+    if (after.date.getTime() >= before.date.getTime()) {
+      return {
+        ok: false,
+        error: "Start time must be before end time."
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        range,
+        startedAfter: after.date.toISOString(),
+        startedBefore: before.date.toISOString()
+      }
+    };
+  }
+  const duration = STUDIO_TIME_RANGE_MILLISECONDS[range];
+  if (!duration) {
+    return { ok: false, error: `Unknown time range "${range}".` };
+  }
+  return {
+    ok: true,
+    value: {
+      range,
+      startedAfter: new Date(now.getTime() - duration).toISOString(),
+      startedBefore: now.toISOString()
+    }
+  };
+};
+var StudioInterruptStatusSchema = import_zod.z.enum([
+  "pending",
+  "resolved",
+  "expired",
+  "failed",
+  "cancelled"
+]);
+var resolveStudioInterruptStatus = (input, now = Date.now()) => {
+  if (input.status !== "pending" || !input.expiresAt) return input.status;
+  const expiresAt = Date.parse(input.expiresAt);
+  const nowMs = typeof now === "number" ? now : now.getTime();
+  return Number.isFinite(expiresAt) && Number.isFinite(nowMs) && expiresAt <= nowMs ? "expired" : input.status;
+};
+var StudioInterruptTypeSchema = import_zod.z.enum([
+  "choice",
+  "multi-choice",
+  "text",
+  "unknown"
+]);
+var StudioInterruptInteractionModeSchema = import_zod.z.enum([
+  "static-options",
+  "dynamic-picker",
+  "freeform",
+  "unknown"
+]);
+var StudioInterruptOptionSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  label: import_zod.z.string().min(1),
+  description: import_zod.z.string().nullable()
+}).strict();
+var StudioResumeOutcomeSchema = import_zod.z.enum([
+  "resumed",
+  "resume failed",
+  "expired before resume",
+  "cancelled"
+]);
+var StudioWorkflowHealthSchema = import_zod.z.enum([
+  "unknown",
+  "healthy",
+  "degraded",
+  "failing",
+  "idle"
+]);
+var StudioPricingStatusSchema = import_zod.z.enum([
+  "priced",
+  "unpriced",
+  "unknown"
+]);
+var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
+var StudioChangeResourceSchema = import_zod.z.enum([
+  "runs",
+  "sessions",
+  "interrupts"
+]);
+var StudioChangeSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(1),
+  changeId: import_zod.z.string().min(1),
+  emittedAt: import_zod.z.string().datetime({ offset: true }),
+  organizationId: import_zod.z.string().min(1),
+  projectId: import_zod.z.string().min(1),
+  resources: import_zod.z.array(StudioChangeResourceSchema).min(1)
+}).strict();
+var StudioMetricSchema = import_zod.z.object({
+  runCount: import_zod.z.number().int().nonnegative(),
+  successRate: import_zod.z.number().min(0).max(100).nullable(),
+  errorRate: import_zod.z.number().min(0).max(100).nullable(),
+  retryCount: import_zod.z.number().int().nonnegative().nullable(),
+  interruptRate: import_zod.z.number().min(0).max(100).nullable(),
+  p50DurationMs: import_zod.z.number().nonnegative().nullable(),
+  p95DurationMs: import_zod.z.number().nonnegative().nullable(),
+  averageTokens: import_zod.z.number().nonnegative().nullable(),
+  averageCost: import_zod.z.number().nonnegative().nullable(),
+  currency: import_zod.z.string().nullable()
+}).strict();
+var StudioRunSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  callerNodeId: import_zod.z.string().optional(),
+  parentRunId: import_zod.z.string().optional(),
+  parentWorkflowId: import_zod.z.string().optional(),
+  invocationId: import_zod.z.string().optional(),
+  branchId: import_zod.z.string().optional(),
+  callId: import_zod.z.string().optional(),
+  status: StudioRunStatusSchema,
+  startedAt: import_zod.z.string().datetime({ offset: true }),
+  endedAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  workflowId: import_zod.z.string().min(1),
+  workflowIds: import_zod.z.array(import_zod.z.string().min(1)),
+  workflowRefs: import_zod.z.array(
+    import_zod.z.object({
+      workflowId: import_zod.z.string().min(1),
+      workflowRevisionId: import_zod.z.string().nullable(),
+      declaredVersion: import_zod.z.string().nullable()
+    }).strict()
+  ),
+  workflowRevisionId: import_zod.z.string().nullable(),
+  declaredVersion: import_zod.z.string().nullable(),
+  transitionIds: import_zod.z.array(import_zod.z.string().min(1)),
+  path: import_zod.z.array(import_zod.z.string()),
+  sessionId: import_zod.z.string().nullable(),
+  provider: import_zod.z.string().nullable(),
+  model: import_zod.z.string().nullable(),
+  models: import_zod.z.array(import_zod.z.string()),
+  durationMs: import_zod.z.number().nonnegative().nullable(),
+  tokens: import_zod.z.number().int().nonnegative().nullable(),
+  cost: import_zod.z.number().nonnegative().nullable(),
+  pricingStatus: StudioPricingStatusSchema,
+  pricingSource: StudioPricingSourceSchema,
+  currency: import_zod.z.string().nullable(),
+  result: import_zod.z.string().nullable(),
+  environment: import_zod.z.string().min(1),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  hasTool: import_zod.z.boolean(),
+  hasRetry: import_zod.z.boolean(),
+  interruptNodeId: import_zod.z.string().nullable(),
+  interruptId: import_zod.z.string().nullable().optional(),
+  interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
+  interruptExpiresAt: import_zod.z.string().datetime({ offset: true }).nullable().optional()
+}).strict();
+var StudioSessionSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  status: StudioRunStatusSchema,
+  lastActivityAt: import_zod.z.string().datetime({ offset: true }),
+  workflowIds: import_zod.z.array(import_zod.z.string()),
+  workflowCount: import_zod.z.number().int().nonnegative(),
+  activeWorkflowId: import_zod.z.string().nullable(),
+  activeVersion: import_zod.z.string().nullable(),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  runs: import_zod.z.number().int().nonnegative(),
+  succeeded: import_zod.z.number().int().nonnegative(),
+  failed: import_zod.z.number().int().nonnegative(),
+  interrupted: import_zod.z.number().int().nonnegative(),
+  checkpoints: import_zod.z.number().int().nonnegative(),
+  hasFork: import_zod.z.boolean(),
+  durationMs: import_zod.z.number().nonnegative().nullable(),
+  tokens: import_zod.z.number().int().nonnegative().nullable(),
+  cost: import_zod.z.number().nonnegative().nullable(),
+  pricingStatus: StudioPricingStatusSchema,
+  pricingSource: StudioPricingSourceSchema,
+  currency: import_zod.z.string().nullable(),
+  latestResult: import_zod.z.string().nullable(),
+  latestError: import_zod.z.string().nullable(),
+  pendingInterruptId: import_zod.z.string().nullable(),
+  interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
+  interruptExpiresAt: import_zod.z.string().datetime({ offset: true }).nullable().optional(),
+  providers: import_zod.z.array(import_zod.z.string()),
+  models: import_zod.z.array(import_zod.z.string()),
+  tags: import_zod.z.array(import_zod.z.string()),
+  environment: import_zod.z.string().min(1)
+}).strict();
+var StudioInterruptSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  status: StudioInterruptStatusSchema,
+  type: StudioInterruptTypeSchema,
+  interactionMode: StudioInterruptInteractionModeSchema,
+  schemaId: import_zod.z.string().nullable(),
+  schemaVersion: import_zod.z.string().nullable(),
+  createdAt: import_zod.z.string().datetime({ offset: true }),
+  resolvedAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  expiresAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  question: import_zod.z.string().nullable(),
+  contentCaptured: import_zod.z.boolean(),
+  optionCount: import_zod.z.number().int().nonnegative().nullable(),
+  options: import_zod.z.array(StudioInterruptOptionSchema).nullable(),
+  workflowId: import_zod.z.string().min(1),
+  nodeId: import_zod.z.string().nullable(),
+  sessionId: import_zod.z.string().nullable(),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  response: import_zod.z.string().nullable(),
+  responseCaptured: import_zod.z.boolean(),
+  resumeOutcome: StudioResumeOutcomeSchema.nullable(),
+  resumeError: import_zod.z.string().nullable(),
+  runId: import_zod.z.string().min(1),
+  resumeToken: import_zod.z.string().nullable(),
+  resolvedBy: import_zod.z.string().nullable(),
+  environment: import_zod.z.string().min(1)
+}).strict();
+var StudioDetailEventSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  type: TelemetryEventTypeSchema,
+  occurredAt: import_zod.z.string().datetime({ offset: true }),
+  receivedAt: import_zod.z.string().datetime({ offset: true }),
+  environment: import_zod.z.string().min(1),
+  serviceName: import_zod.z.string().min(1),
+  deploymentRef: import_zod.z.string().nullable(),
+  traceId: import_zod.z.string().nullable(),
+  spanId: import_zod.z.string().nullable(),
+  parentSpanId: import_zod.z.string().nullable(),
+  runId: import_zod.z.string().min(1),
+  sessionId: import_zod.z.string().nullable(),
+  workflowId: import_zod.z.string().min(1),
+  workflowRevisionId: import_zod.z.string().nullable(),
+  nodeId: import_zod.z.string().nullable(),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  tags: import_zod.z.array(import_zod.z.string()),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullable(),
+  payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
+}).strict();
+var StudioWorkflowNodeSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  label: import_zod.z.string(),
+  type: import_zod.z.string().nullable(),
+  state: import_zod.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
+  provider: import_zod.z.string().nullable(),
+  model: import_zod.z.string().nullable(),
+  metrics: StudioMetricSchema
+}).strict();
+var StudioWorkflowInternalEdgeSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  source: import_zod.z.string().min(1),
+  target: import_zod.z.string().min(1),
+  condition: import_zod.z.string().nullable()
+}).strict();
+var StudioWorkflowTransitionSchema = import_zod.z.object({
+  kind: import_zod.z.enum(["call", "handoff"]).optional(),
+  id: import_zod.z.string().min(1),
+  sourceWorkflowId: import_zod.z.string().min(1),
+  sourceNodeId: import_zod.z.string().nullable(),
+  targetWorkflowId: import_zod.z.string().min(1),
+  condition: import_zod.z.string().nullable(),
+  volume: import_zod.z.number().int().nonnegative(),
+  successRate: import_zod.z.number().min(0).max(100).nullable(),
+  medianDurationMs: import_zod.z.number().nonnegative().nullable(),
+  errorRate: import_zod.z.number().min(0).max(100).nullable()
+}).strict();
+var StudioWorkflowSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  name: import_zod.z.string().min(1),
+  description: import_zod.z.string().nullable(),
+  versions: import_zod.z.array(import_zod.z.string()),
+  activeVersion: import_zod.z.string().nullable(),
+  activeRevisionId: import_zod.z.string().nullable(),
+  health: StudioWorkflowHealthSchema,
+  tags: import_zod.z.array(import_zod.z.string()),
+  lastActivityAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  metrics: StudioMetricSchema,
+  nodes: import_zod.z.array(StudioWorkflowNodeSchema),
+  internalEdges: import_zod.z.array(StudioWorkflowInternalEdgeSchema)
+}).strict();
+var StudioRunsResponseSchema = import_zod.z.object({
+  runs: import_zod.z.array(StudioRunSchema),
+  totalCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var StudioSessionsResponseSchema = import_zod.z.object({
+  sessions: import_zod.z.array(StudioSessionSchema),
+  totalCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var StudioInterruptsResponseSchema = import_zod.z.object({
+  interrupts: import_zod.z.array(StudioInterruptSchema),
+  totalCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var StudioRunDetailResponseSchema = import_zod.z.object({
+  run: StudioRunSchema,
+  events: import_zod.z.array(StudioDetailEventSchema),
+  session: StudioSessionSchema.nullable(),
+  interrupts: import_zod.z.array(StudioInterruptSchema),
+  updatedAt: import_zod.z.string().datetime({ offset: true })
+}).strict();
+var StudioSessionDetailResponseSchema = import_zod.z.object({
+  session: StudioSessionSchema,
+  runs: import_zod.z.array(StudioRunSchema),
+  events: import_zod.z.array(StudioDetailEventSchema),
+  interrupts: import_zod.z.array(StudioInterruptSchema),
+  updatedAt: import_zod.z.string().datetime({ offset: true })
+}).strict();
+var StudioInterruptDetailResponseSchema = import_zod.z.object({
+  interrupt: StudioInterruptSchema,
+  events: import_zod.z.array(StudioDetailEventSchema),
+  run: StudioRunSchema.nullable(),
+  session: StudioSessionSchema.nullable(),
+  updatedAt: import_zod.z.string().datetime({ offset: true })
+}).strict();
+var StudioWorkflowsResponseSchema = import_zod.z.object({
+  workflows: import_zod.z.array(StudioWorkflowSchema),
+  observedCalls: import_zod.z.array(
+    StudioWorkflowTransitionSchema.extend({
+      runId: import_zod.z.string(),
+      invocationId: import_zod.z.string(),
+      branchId: import_zod.z.string()
+    })
+  ).optional(),
+  transitions: import_zod.z.array(StudioWorkflowTransitionSchema),
+  cohort: StudioTimeRangeContextSchema.extend({
+    workflowId: import_zod.z.string().nullable(),
+    version: import_zod.z.string().nullable()
+  }).strict()
+}).strict();
+var StudioCatalogsResponseSchema = import_zod.z.object({
+  environments: import_zod.z.array(import_zod.z.string()),
+  providers: import_zod.z.array(import_zod.z.string()),
+  models: import_zod.z.array(import_zod.z.string()),
+  workflows: import_zod.z.array(import_zod.z.string()),
+  tags: import_zod.z.array(import_zod.z.string())
+}).strict();
+var StudioContextResponseSchema = import_zod.z.object({
+  organization: import_zod.z.object({
+    name: import_zod.z.string().min(1)
+  }).strict(),
+  project: import_zod.z.object({
+    name: import_zod.z.string().min(1)
+  }).strict(),
+  environments: import_zod.z.array(import_zod.z.string()),
+  apiKey: import_zod.z.object({
+    mode: import_zod.z.enum(["test", "live"]),
+    scopes: import_zod.z.array(import_zod.z.string())
+  }).strict(),
+  api: import_zod.z.object({
+    status: import_zod.z.literal("ok"),
+    service: import_zod.z.literal("kortyx-api"),
+    version: import_zod.z.string().min(1)
+  }).strict()
+}).strict();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema,
+  STUDIO_TIME_RANGES,
+  StudioCatalogsResponseSchema,
+  StudioChangeResourceSchema,
+  StudioChangeSchema,
+  StudioContextResponseSchema,
+  StudioDetailEventSchema,
+  StudioInterruptDetailResponseSchema,
+  StudioInterruptInteractionModeSchema,
+  StudioInterruptOptionSchema,
+  StudioInterruptSchema,
+  StudioInterruptStatusSchema,
+  StudioInterruptTypeSchema,
+  StudioInterruptsResponseSchema,
+  StudioMetricSchema,
+  StudioPricingSourceSchema,
+  StudioPricingStatusSchema,
+  StudioResumeOutcomeSchema,
+  StudioRunDetailResponseSchema,
+  StudioRunSchema,
+  StudioRunStatusSchema,
+  StudioRunsResponseSchema,
+  StudioSessionDetailResponseSchema,
+  StudioSessionSchema,
+  StudioSessionsResponseSchema,
+  StudioTimeRangeContextSchema,
+  StudioTimeRangeQuerySchema,
+  StudioTimeRangeSchema,
+  StudioWorkflowHealthSchema,
+  StudioWorkflowInternalEdgeSchema,
+  StudioWorkflowNodeSchema,
+  StudioWorkflowSchema,
+  StudioWorkflowTransitionSchema,
+  StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES,
+  TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema,
   TelemetryEventSchema,
   TelemetryEventTypeSchema,
+  TelemetryPricingHintSchema,
+  TelemetryPricingLineItemSchema,
+  TelemetryPricingSourceSchema,
+  TelemetryPricingUnitSchema,
+  TelemetryPricingUsageTypeSchema,
   TelemetryServiceSchema,
+  TelemetryUnitPriceSchema,
+  TelemetryUsageItemSchema,
+  WorkflowTopologyCallSchema,
   WorkflowTopologyEdgeSchema,
-  WorkflowTopologyNodeSchema
+  WorkflowTopologyNodeSchema,
+  WorkflowTopologyTransitionSchema,
+  projectWorkflowCalls,
+  resolveStudioInterruptStatus,
+  resolveStudioTimeRange
 });
 //# sourceMappingURL=index.js.map