qati-sdk 1.0.0 → 1.0.2

package/README.md

@@ -550,15 +550,3 @@ Transient failures are retried automatically for **`POST /v1/events:batch`** acc
 | Errors          | `QatiSDKError`, `QatiAPIError`, `QatiAuthError`, `QatiNotFoundError`, `QatiRateLimitError`, `QatiServerError`, `QatiConfigError`.                                                                          |
 
 `HttpClient.request(...)` exists for advanced use; prefer resource methods for application code.
-
-## Build (maintainers)
-
-From `sdks/typescript/`:
-
-```bash
-npm ci
-npm test
-npm run build
-```
-
-Outputs land in `dist/` (ESM + CJS + declarations).

package/dist/index.cjs

@@ -640,7 +640,7 @@ var TrustStateResource = class {
   /**
    * Fetches the latest trust state for one entity.
    *
-   * @param entityType - Lowercase entity class: `user`, `device`, `account`, `model`, `session`, or `service` (see {@link EntityTypeLowerCase}).
+   * @param entityType - Lowercase entity class (see {@link EntityTypeLowerCase}).
    * @param entityId - Id for the entity(Required)
    * @param options - Optional contributor limits/window.
    * @returns {@link TrustState} including `current_closure_score`, `risk_tier`, and `top_contributors`.
@@ -661,7 +661,7 @@ var TrustStateResource = class {
   /**
    * Fetches trust states for many entities in one request.
    *
-   * @param entityType - Lowercase entity class: `user`, `device`, `account`, `model`, `session`, or `service` (see {@link EntityTypeLowerCase}).
+   * @param entityType - Lowercase entity class (see {@link EntityTypeLowerCase}).
    * @param entityIds - Distinct ids to query. Prefer length ≤ 100 or the server may reject the request.
    * @param options - Optional contributor limits/window.
    * @returns Array of {@link TrustState} in server-defined order; empty array when `entityIds` is empty.
@@ -780,6 +780,9 @@ var Session = class {
     return new Client(this._config, httpClients ?? {});
   }
 };
+var fraction01 = () => zod.z.number().min(0).max(1);
+var fraction01Nullable = () => fraction01().nullable().optional();
+var nonEmptyString = () => zod.z.string().min(1);
 
 // src/shared/types/signal-type.ts
 var SIGNAL_TYPES = [
@@ -789,7 +792,16 @@ var SIGNAL_TYPES = [
   "SYSTEM_TELEMETRY",
   "MODEL_OUTPUT",
   "ANOMALY_FLAG",
-  "NETWORK_EVENT"
+  "NETWORK_EVENT",
+  "SESSION",
+  "PROMPT_INPUT",
+  "CONTEXT_INTEGRITY",
+  "TOOL_CALL",
+  "RAG_RETRIEVAL",
+  "POLICY_EVENT",
+  "USER_FEEDBACK",
+  "WORKFLOW_ACTION",
+  "API_CALL"
 ];
 
 // src/shared/types/provenance-mode.ts
@@ -816,8 +828,13 @@ var EventPrincipalSchema = zod.z.object({
   device_id: zod.z.string().min(1).optional(),
   session_id: zod.z.string().min(1).optional(),
   model_id: zod.z.string().min(1).optional(),
-  service_id: zod.z.string().min(1).optional()
-});
+  service_id: zod.z.string().min(1).optional(),
+  conversation_id: zod.z.string().min(1).optional(),
+  document_id: zod.z.string().min(1).optional(),
+  tool_id: zod.z.string().min(1).optional(),
+  workflow_id: zod.z.string().min(1).optional(),
+  api_key_id: zod.z.string().min(1).optional()
+}).strict();
 
 // src/v1/schemas/raw-event.ts
 var BaseEventSchema = zod.z.object({
@@ -838,103 +855,15 @@ var RawEventRequestSchema = zod.z.object({
   payload: zod.z.record(zod.z.any()).describe("JSON payload (stored as JSONB in DB).")
 });
 
-// src/v1/schemas/signal-payload.ts
-var TransactionSignalPayloadSchema = zod.z.object({
-  amount: zod.z.number().nonnegative().default(0),
-  amount_minor: zod.z.number().int().nonnegative().nullable().optional(),
-  amount_usd: zod.z.number().nonnegative().nullable().optional(),
-  currency: zod.z.string().nullable().optional(),
-  merchant_category: zod.z.string().nullable().optional(),
-  merchant_id: zod.z.string().nullable().optional(),
-  channel: zod.z.string().nullable().optional(),
-  country: zod.z.string().nullable().optional(),
-  velocity: zod.z.number().nonnegative().nullable().optional(),
-  external_anomaly_score: zod.z.number().nullable().optional(),
-  geo_distance: zod.z.number().nonnegative().nullable().optional(),
-  geo_distance_km: zod.z.number().nonnegative().nullable().optional(),
-  records_accessed: zod.z.number().int().nonnegative().nullable().optional(),
-  baseline_records_accessed: zod.z.number().int().nonnegative().nullable().optional(),
-  sensitivity_level: zod.z.string().nullable().optional(),
-  export_count: zod.z.number().int().nonnegative().nullable().optional(),
-  bulk_export: zod.z.boolean().optional().default(false),
-  contains_phi: zod.z.boolean().optional().default(false),
-  control_command: zod.z.string().nullable().optional(),
-  authorized: zod.z.boolean().nullable().optional(),
-  safety_critical: zod.z.boolean().optional().default(false)
-});
-var AuthSignalPayloadSchema = zod.z.object({
-  result: zod.z.string().nullable().optional(),
-  auth_method: zod.z.string().nullable().optional(),
-  mfa_used: zod.z.boolean().nullable().optional(),
-  mfa_bypassed: zod.z.boolean().optional().default(false),
-  failed_attempts: zod.z.number().int().nonnegative().optional().default(0),
-  ip: zod.z.string().nullable().optional(),
-  country: zod.z.string().nullable().optional(),
-  user_agent: zod.z.string().nullable().optional(),
-  unusual_location: zod.z.boolean().optional().default(false),
-  after_hours_login: zod.z.boolean().optional().default(false)
-});
-var ModelOutputSignalPayloadSchema = zod.z.object({
-  missing_citations_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  citation_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  expected_citation_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  policy_violations: zod.z.number().int().nonnegative().optional().default(0),
-  policy_violation_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  tool_call_inconsistency: zod.z.number().min(0).max(1).optional().default(0),
-  tool_inconsistency_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  tool_miss_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  eval_window_n: zod.z.number().int().min(1).nullable().optional()
-});
-var SystemTelemetrySignalPayloadSchema = zod.z.object({
-  metric_name: zod.z.string().nullable().optional(),
-  value: zod.z.number().nullable().optional(),
-  baseline: zod.z.number().nullable().optional(),
-  window_seconds: zod.z.number().int().min(1).nullable().optional(),
-  error_rate: zod.z.number().min(0).max(1).optional().default(0),
-  baseline_error_rate: zod.z.number().min(0).max(1).nullable().optional(),
-  unusual_auth_rate: zod.z.number().min(0).max(1).optional().default(0),
-  firmware_hash_changed: zod.z.boolean().optional().default(false),
-  expected_hash_match: zod.z.boolean().nullable().optional(),
-  sensor_deviation_score: zod.z.number().min(0).max(1).nullable().optional()
-});
+// src/v1/schemas/anomaly-flag.ts
 var AnomalyFlagSignalPayloadSchema = zod.z.object({
-  severity: zod.z.number().min(0).max(1)
-});
-var BehaviorSignalPayloadSchema = zod.z.object({
-  deviation_score: zod.z.number().min(0).max(1)
-});
-var NetworkSignalPayloadSchema = zod.z.object({
-  ip: zod.z.string().nullable().optional(),
-  asn: zod.z.string().nullable().optional(),
-  reputation_score: zod.z.number().min(0).max(1).nullable().optional(),
-  threat_score: zod.z.number().min(0).max(1).nullable().optional(),
-  is_datacenter: zod.z.boolean().nullable().optional(),
-  is_untrusted_segment: zod.z.boolean().optional().default(false),
-  asn_reputation: zod.z.number().min(0).max(1).nullable().optional()
-});
-BaseEventSchema.extend({
-  signal_payload: TransactionSignalPayloadSchema
+  severity: fraction01()
 });
 BaseEventSchema.extend({
   signal_payload: AnomalyFlagSignalPayloadSchema
 });
-BaseEventSchema.extend({
-  signal_payload: AuthSignalPayloadSchema
-});
-BaseEventSchema.extend({
-  signal_payload: BehaviorSignalPayloadSchema
-});
-BaseEventSchema.extend({
-  signal_payload: NetworkSignalPayloadSchema
-});
-BaseEventSchema.extend({
-  signal_payload: ModelOutputSignalPayloadSchema
-});
-BaseEventSchema.extend({
-  signal_payload: SystemTelemetrySignalPayloadSchema
-});
 
-// src/v1/builders/event-builder.ts
+// src/v1/builders/_common.ts
 var buildRawEventPayload = (event, signalPayload, signalType) => {
   const rawEventPayload = {
     timestamp: event.timestamp,
@@ -960,36 +889,296 @@ var buildRawEventRequest = (event, signalPayload, signalType) => {
     payload: rawEventPayload
   };
 };
-var createAuthEvent = (event) => {
-  const signalPayload = AuthSignalPayloadSchema.parse(event.signal_payload);
-  return buildRawEventRequest(event, signalPayload, "AUTH");
-};
-function createTransactionEvent(event) {
-  const signalPayload = TransactionSignalPayloadSchema.parse(
-    event.signal_payload
-  );
-  return buildRawEventRequest(event, signalPayload, "TRANSACTION");
-}
+
+// src/v1/builders/anomaly-flag-builder.ts
 var createAnomalyFlagEvent = (event) => {
   const signalPayload = AnomalyFlagSignalPayloadSchema.parse(
     event.signal_payload
   );
   return buildRawEventRequest(event, signalPayload, "ANOMALY_FLAG");
 };
+
+// src/shared/types/http-method.ts
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+
+// src/v1/schemas/api-call.ts
+var ApiCallSignalPayloadSchema = zod.z.object({
+  service_id: nonEmptyString(),
+  endpoint: nonEmptyString(),
+  method: zod.z.enum(HTTP_METHODS),
+  status_code: zod.z.number().int().min(100).max(599),
+  authorized: zod.z.boolean().nullable(),
+  authentication_present: zod.z.boolean().nullable().optional(),
+  rate_limited: zod.z.boolean().nullable().optional(),
+  external_side_effect: zod.z.boolean().nullable().optional(),
+  records_returned: zod.z.number().int().nonnegative().nullable().optional(),
+  records_modified: zod.z.number().int().nonnegative().nullable().optional(),
+  contains_sensitive_data: zod.z.boolean().nullable().optional(),
+  latency_ms: zod.z.number().nonnegative().nullable().optional(),
+  retry_count: zod.z.number().int().nonnegative().nullable().optional(),
+  api_key_id: zod.z.string().nullable().optional()
+});
+BaseEventSchema.extend({
+  signal_payload: ApiCallSignalPayloadSchema
+});
+
+// src/v1/builders/api-call-builder.ts
+var createApiCallEvent = (event) => {
+  const signalPayload = ApiCallSignalPayloadSchema.parse(event.signal_payload);
+  return buildRawEventRequest(event, signalPayload, "API_CALL");
+};
+var AuthSignalPayloadSchema = zod.z.object({
+  result: zod.z.string().nullable().optional(),
+  auth_method: zod.z.string().nullable().optional(),
+  mfa_used: zod.z.boolean().nullable().optional(),
+  mfa_bypassed: zod.z.boolean().optional().default(false),
+  failed_attempts: zod.z.number().int().nonnegative().optional().default(0),
+  ip: zod.z.string().nullable().optional(),
+  country: zod.z.string().nullable().optional(),
+  user_agent: zod.z.string().nullable().optional(),
+  unusual_location: zod.z.boolean().optional().default(false),
+  after_hours_login: zod.z.boolean().optional().default(false)
+});
+BaseEventSchema.extend({
+  signal_payload: AuthSignalPayloadSchema
+});
+
+// src/v1/builders/auth-builder.ts
+var createAuthEvent = (event) => {
+  const signalPayload = AuthSignalPayloadSchema.parse(event.signal_payload);
+  return buildRawEventRequest(event, signalPayload, "AUTH");
+};
+var BehaviorSignalPayloadSchema = zod.z.object({
+  deviation_score: fraction01()
+});
+BaseEventSchema.extend({
+  signal_payload: BehaviorSignalPayloadSchema
+});
+
+// src/v1/builders/behavior-builder.ts
 var createBehaviorEvent = (event) => {
   const signalPayload = BehaviorSignalPayloadSchema.parse(event.signal_payload);
   return buildRawEventRequest(event, signalPayload, "BEHAVIOR");
 };
-var createNetworkEvent = (event) => {
-  const signalPayload = NetworkSignalPayloadSchema.parse(event.signal_payload);
-  return buildRawEventRequest(event, signalPayload, "NETWORK_EVENT");
+
+// src/shared/types/context-integrity.ts
+var CONTEXT_SOURCES = [
+  "CONVERSATION_HISTORY",
+  "RETRIEVED_DOCUMENT",
+  "TOOL_OUTPUT",
+  "SYSTEM",
+  "DEVELOPER",
+  "USER"
+];
+
+// src/v1/schemas/context-integrity.ts
+var ContextIntegritySignalPayloadSchema = zod.z.object({
+  context_source: zod.z.enum(CONTEXT_SOURCES),
+  instruction_conflict_detected: zod.z.boolean(),
+  untrusted_instruction_detected: zod.z.boolean(),
+  context_priority_violation: zod.z.boolean(),
+  recursive_instruction_pattern: zod.z.boolean().optional().default(false),
+  context_drift_score: fraction01Nullable(),
+  system_prompt_conflict_score: fraction01Nullable(),
+  developer_prompt_conflict_score: fraction01Nullable(),
+  retrieved_instruction_count: zod.z.number().int().nonnegative().optional().default(0),
+  hidden_instruction_score: fraction01Nullable(),
+  source_document_id: zod.z.string().nullable().optional(),
+  untrusted_source_count: zod.z.number().int().nonnegative().optional().default(0),
+  source_trust_score: fraction01Nullable(),
+  lowest_source_trust_score: fraction01Nullable(),
+  recursive_pattern_score: fraction01Nullable(),
+  prompt_injection_score: fraction01Nullable(),
+  contains_instruction_override: zod.z.boolean().optional().default(false),
+  context_injection_score: fraction01Nullable()
+});
+BaseEventSchema.extend({
+  signal_payload: ContextIntegritySignalPayloadSchema
+});
+
+// src/v1/builders/context-integrity-builder.ts
+var createContextIntegrityEvent = (event) => {
+  const signalPayload = ContextIntegritySignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "CONTEXT_INTEGRITY");
 };
+var ModelOutputSignalPayloadSchema = zod.z.object({
+  missing_citations_rate: fraction01Nullable(),
+  citation_rate: fraction01Nullable(),
+  expected_citation_rate: fraction01Nullable(),
+  policy_violations: zod.z.number().int().nonnegative().optional().default(0),
+  policy_violation_rate: fraction01Nullable(),
+  tool_call_inconsistency: fraction01().optional().default(0),
+  tool_inconsistency_rate: fraction01Nullable(),
+  tool_miss_rate: fraction01Nullable(),
+  eval_window_n: zod.z.number().int().min(1).nullable().optional(),
+  hallucination_risk_score: fraction01Nullable(),
+  self_contradiction_score: fraction01Nullable(),
+  grounding_score: fraction01Nullable(),
+  contains_unsupported_claims: zod.z.boolean().optional().default(false)
+});
+BaseEventSchema.extend({
+  signal_payload: ModelOutputSignalPayloadSchema
+});
+
+// src/v1/builders/model-output-builder.ts
 var createModelOutputEvent = (event) => {
   const signalPayload = ModelOutputSignalPayloadSchema.parse(
     event.signal_payload
   );
   return buildRawEventRequest(event, signalPayload, "MODEL_OUTPUT");
 };
+var NetworkSignalPayloadSchema = zod.z.object({
+  ip: zod.z.string().nullable().optional(),
+  asn: zod.z.string().nullable().optional(),
+  reputation_score: fraction01Nullable(),
+  threat_score: fraction01Nullable(),
+  is_datacenter: zod.z.boolean().nullable().optional(),
+  is_untrusted_segment: zod.z.boolean().optional().default(false),
+  asn_reputation: fraction01Nullable()
+});
+BaseEventSchema.extend({
+  signal_payload: NetworkSignalPayloadSchema
+});
+
+// src/v1/builders/network-builder.ts
+var createNetworkEvent = (event) => {
+  const signalPayload = NetworkSignalPayloadSchema.parse(event.signal_payload);
+  return buildRawEventRequest(event, signalPayload, "NETWORK_EVENT");
+};
+
+// src/shared/types/policy-event.ts
+var POLICY_CATEGORIES = [
+  "SAFETY",
+  "PRIVACY",
+  "SECURITY",
+  "COMPLIANCE",
+  "CONTENT",
+  "OTHER"
+];
+var POLICY_RESULTS = ["PASS", "WARN", "FAIL", "BLOCKED"];
+
+// src/v1/schemas/policy-event.ts
+var PolicyEventSignalPayloadSchema = zod.z.object({
+  policy_check_name: nonEmptyString(),
+  policy_category: zod.z.enum(POLICY_CATEGORIES),
+  policy_result: zod.z.enum(POLICY_RESULTS),
+  severity: fraction01(),
+  blocked: zod.z.boolean().optional().default(false),
+  violation_count: zod.z.number().int().nonnegative().optional().default(0),
+  policy_confidence: fraction01Nullable(),
+  redaction_applied: zod.z.boolean().optional().default(false)
+});
+BaseEventSchema.extend({
+  signal_payload: PolicyEventSignalPayloadSchema
+});
+
+// src/v1/builders/policy-event-builder.ts
+var createPolicyEvent = (event) => {
+  const signalPayload = PolicyEventSignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "POLICY_EVENT");
+};
+var promptHashSchema = zod.z.string().regex(/^[a-fA-F0-9]{64}$/).optional();
+var PromptInputSignalPayloadSchema = zod.z.object({
+  prompt_length_chars: zod.z.number().int().nonnegative(),
+  conversation_turn_index: zod.z.number().int().nonnegative(),
+  contains_instruction_override: zod.z.boolean(),
+  contains_tool_request: zod.z.boolean().optional().default(false),
+  contains_secret_request: zod.z.boolean().optional().default(false),
+  contains_policy_challenge: zod.z.boolean().optional().default(false),
+  recursive_pattern_score: fraction01Nullable(),
+  prompt_injection_score: fraction01Nullable(),
+  sensitive_domain: zod.z.boolean().optional().default(false),
+  complexity_score: fraction01Nullable(),
+  prompt_hash: promptHashSchema
+});
+BaseEventSchema.extend({
+  signal_payload: PromptInputSignalPayloadSchema
+});
+
+// src/v1/builders/prompt-input-builder.ts
+var createPromptInputEvent = (event) => {
+  const signalPayload = PromptInputSignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "PROMPT_INPUT");
+};
+var RagRetrievalSignalPayloadSchema = zod.z.object({
+  retriever_id: nonEmptyString(),
+  query_hash: zod.z.string().nullable().optional(),
+  documents_retrieved: zod.z.number().int().nonnegative(),
+  top_k: zod.z.number().int().min(1),
+  average_relevance_score: fraction01(),
+  source_trust_score: fraction01(),
+  lowest_source_trust_score: fraction01Nullable(),
+  untrusted_source_count: zod.z.number().int().nonnegative().optional().default(0),
+  retrieved_context_tokens: zod.z.number().int().nonnegative().optional().default(0),
+  context_injection_score: fraction01().optional().default(0),
+  document_ids: zod.z.array(zod.z.string()).optional().default([])
+});
+BaseEventSchema.extend({
+  signal_payload: RagRetrievalSignalPayloadSchema
+});
+
+// src/v1/builders/rag-retrieval-builder.ts
+var createRagRetrievalEvent = (event) => {
+  const signalPayload = RagRetrievalSignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "RAG_RETRIEVAL");
+};
+
+// src/shared/types/session.ts
+var SESSION_STATUSES = [
+  "STARTED",
+  "ACTIVE",
+  "ENDED",
+  "TIMEOUT",
+  "ABANDONED"
+];
+
+// src/v1/schemas/session.ts
+var SessionSignalPayloadSchema = zod.z.object({
+  session_status: zod.z.enum(SESSION_STATUSES),
+  session_age_seconds: zod.z.number().nonnegative().optional().default(0),
+  turn_count: zod.z.number().int().nonnegative().optional().default(0),
+  messages_last_minute: zod.z.number().nonnegative().optional().default(0),
+  avg_seconds_between_turns: zod.z.number().nonnegative().nullable().optional(),
+  restart_count_10m: zod.z.number().int().nonnegative().optional().default(0),
+  session_timeout: zod.z.boolean().optional().default(false),
+  abandoned: zod.z.boolean().optional().default(false),
+  conversation_id: zod.z.string().nullable().optional(),
+  user_id: zod.z.string().nullable().optional()
+});
+BaseEventSchema.extend({
+  signal_payload: SessionSignalPayloadSchema
+});
+
+// src/v1/builders/session-builder.ts
+var createSessionEvent = (event) => {
+  const signalPayload = SessionSignalPayloadSchema.parse(event.signal_payload);
+  return buildRawEventRequest(event, signalPayload, "SESSION");
+};
+var SystemTelemetrySignalPayloadSchema = zod.z.object({
+  metric_name: zod.z.string().nullable().optional(),
+  value: zod.z.number().nullable().optional(),
+  baseline: zod.z.number().nullable().optional(),
+  window_seconds: zod.z.number().int().min(1).nullable().optional(),
+  error_rate: fraction01().optional().default(0),
+  baseline_error_rate: fraction01Nullable(),
+  unusual_auth_rate: fraction01().optional().default(0),
+  firmware_hash_changed: zod.z.boolean().optional().default(false),
+  expected_hash_match: zod.z.boolean().nullable().optional(),
+  sensor_deviation_score: fraction01Nullable()
+});
+BaseEventSchema.extend({
+  signal_payload: SystemTelemetrySignalPayloadSchema
+});
+
+// src/v1/builders/system-telemetry-builder.ts
 var createSystemTelemetryEvent = (event) => {
   const signalPayload = SystemTelemetrySignalPayloadSchema.parse(
     event.signal_payload
@@ -997,6 +1186,172 @@ var createSystemTelemetryEvent = (event) => {
   return buildRawEventRequest(event, signalPayload, "SYSTEM_TELEMETRY");
 };
 
+// src/shared/types/tool-call.ts
+var TOOL_CATEGORIES = [
+  "RETRIEVAL",
+  "DATABASE",
+  "PAYMENT",
+  "MESSAGING",
+  "CODE_EXECUTION",
+  "FILE",
+  "EXTERNAL_API",
+  "OTHER"
+];
+
+// src/v1/schemas/tool-call.ts
+var ToolCallSignalPayloadSchema = zod.z.object({
+  tool_name: nonEmptyString(),
+  tool_category: zod.z.enum(TOOL_CATEGORIES),
+  action: nonEmptyString(),
+  authorized: zod.z.boolean().nullable(),
+  safety_critical: zod.z.boolean(),
+  external_side_effect: zod.z.boolean(),
+  tool_call_success: zod.z.boolean().nullable().optional(),
+  latency_ms: zod.z.number().nonnegative().nullable().optional(),
+  error_code: zod.z.string().nullable().optional(),
+  argument_risk_score: fraction01Nullable(),
+  result_size_bytes: zod.z.number().int().nonnegative().nullable().optional(),
+  records_accessed: zod.z.number().int().nonnegative().optional().default(0),
+  contains_sensitive_data: zod.z.boolean().optional().default(false),
+  action_category: zod.z.string().nullable().optional(),
+  method: zod.z.string().nullable().optional(),
+  sensitive_data_involved: zod.z.boolean().optional().default(false),
+  contains_phi: zod.z.boolean().optional().default(false),
+  sensitive_domain: zod.z.boolean().optional().default(false)
+});
+BaseEventSchema.extend({
+  signal_payload: ToolCallSignalPayloadSchema
+});
+
+// src/v1/builders/tool-call-builder.ts
+var createToolCallEvent = (event) => {
+  const signalPayload = ToolCallSignalPayloadSchema.parse(event.signal_payload);
+  return buildRawEventRequest(event, signalPayload, "TOOL_CALL");
+};
+var TransactionSignalPayloadSchema = zod.z.object({
+  amount: zod.z.number().nonnegative().default(0),
+  amount_minor: zod.z.number().int().nonnegative().nullable().optional(),
+  amount_usd: zod.z.number().nonnegative().nullable().optional(),
+  currency: zod.z.string().nullable().optional(),
+  merchant_category: zod.z.string().nullable().optional(),
+  merchant_id: zod.z.string().nullable().optional(),
+  channel: zod.z.string().nullable().optional(),
+  country: zod.z.string().nullable().optional(),
+  velocity: zod.z.number().nonnegative().nullable().optional(),
+  external_anomaly_score: zod.z.number().nullable().optional(),
+  geo_distance: zod.z.number().nonnegative().nullable().optional(),
+  geo_distance_km: zod.z.number().nonnegative().nullable().optional(),
+  records_accessed: zod.z.number().int().nonnegative().nullable().optional(),
+  baseline_records_accessed: zod.z.number().int().nonnegative().nullable().optional(),
+  sensitivity_level: zod.z.string().nullable().optional(),
+  export_count: zod.z.number().int().nonnegative().nullable().optional(),
+  bulk_export: zod.z.boolean().optional().default(false),
+  contains_phi: zod.z.boolean().optional().default(false),
+  control_command: zod.z.string().nullable().optional(),
+  authorized: zod.z.boolean().nullable().optional(),
+  safety_critical: zod.z.boolean().optional().default(false)
+});
+BaseEventSchema.extend({
+  signal_payload: TransactionSignalPayloadSchema
+});
+
+// src/v1/builders/transaction-builder.ts
+var createTransactionEvent = (event) => {
+  const signalPayload = TransactionSignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "TRANSACTION");
+};
+
+// src/shared/types/user-feedback.ts
+var FEEDBACK_TYPES = [
+  "THUMBS_UP",
+  "THUMBS_DOWN",
+  "REPORT",
+  "CORRECTION",
+  "RATING"
+];
+var FEEDBACK_ISSUE_TYPES = [
+  "HALLUCINATION",
+  "UNSAFE",
+  "IRRELEVANT",
+  "PRIVACY",
+  "OFFENSIVE",
+  "OTHER"
+];
+
+// src/v1/schemas/user-feedback.ts
+var UserFeedbackSignalPayloadSchema = zod.z.object({
+  feedback_type: zod.z.enum(FEEDBACK_TYPES),
+  rating: zod.z.number().nullable().optional(),
+  reported_issue: zod.z.boolean().optional().default(false),
+  issue_type: zod.z.enum(FEEDBACK_ISSUE_TYPES).nullable().optional(),
+  severity: fraction01Nullable(),
+  response_id: zod.z.string().nullable().optional(),
+  user_comment_hash: zod.z.string().nullable().optional()
+});
+BaseEventSchema.extend({
+  signal_payload: UserFeedbackSignalPayloadSchema
+});
+
+// src/v1/builders/user-feedback-builder.ts
+var createUserFeedbackEvent = (event) => {
+  const signalPayload = UserFeedbackSignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "USER_FEEDBACK");
+};
+
+// src/shared/types/workflow-action.ts
+var WORKFLOW_ACTION_CATEGORIES = [
+  "FINANCIAL",
+  "DATA_ACCESS",
+  "COMMUNICATION",
+  "ADMIN",
+  "SECURITY",
+  "CODE",
+  "OTHER"
+];
+var WORKFLOW_ACTION_STAGES = [
+  "PROPOSED",
+  "PRE_EXECUTION",
+  "EXECUTED",
+  "FAILED",
+  "ROLLED_BACK"
+];
+var WORKFLOW_ACTOR_TYPES = ["USER", "AI_AGENT", "SYSTEM"];
+
+// src/v1/schemas/workflow-action.ts
+var WorkflowActionSignalPayloadSchema = zod.z.object({
+  workflow_id: nonEmptyString(),
+  workflow_type: nonEmptyString(),
+  action_name: nonEmptyString(),
+  action_category: zod.z.enum(WORKFLOW_ACTION_CATEGORIES),
+  action_stage: zod.z.enum(WORKFLOW_ACTION_STAGES),
+  actor_type: zod.z.enum(WORKFLOW_ACTOR_TYPES),
+  requires_approval: zod.z.boolean().optional().default(false),
+  approval_present: zod.z.boolean().optional().default(false),
+  external_side_effect: zod.z.boolean().nullable().optional(),
+  safety_critical: zod.z.boolean().nullable().optional(),
+  amount_usd: zod.z.number().nonnegative().nullable().optional(),
+  sensitive_data_involved: zod.z.boolean().optional().default(false),
+  new_counterparty: zod.z.boolean().optional().default(false),
+  is_new_vendor: zod.z.boolean().optional().default(false),
+  is_new_recipient: zod.z.boolean().optional().default(false),
+  is_new_endpoint: zod.z.boolean().optional().default(false)
+});
+BaseEventSchema.extend({
+  signal_payload: WorkflowActionSignalPayloadSchema
+});
+
+// src/v1/builders/workflow-action-builder.ts
+var createWorkflowActionEvent = (event) => {
+  const signalPayload = WorkflowActionSignalPayloadSchema.parse(
+    event.signal_payload
+  );
+  return buildRawEventRequest(event, signalPayload, "WORKFLOW_ACTION");
+};
+
 exports.API_REGISTRY = API_REGISTRY;
 exports.QatiAPIError = QatiAPIError;
 exports.QatiAuthError = QatiAuthError;
@@ -1009,12 +1364,21 @@ exports.RawEventRequestSchema = RawEventRequestSchema;
 exports.Session = Session;
 exports.baseUrlFor = baseUrlFor;
 exports.createAnomalyFlagEvent = createAnomalyFlagEvent;
+exports.createApiCallEvent = createApiCallEvent;
 exports.createAuthEvent = createAuthEvent;
 exports.createBehaviorEvent = createBehaviorEvent;
+exports.createContextIntegrityEvent = createContextIntegrityEvent;
 exports.createModelOutputEvent = createModelOutputEvent;
 exports.createNetworkEvent = createNetworkEvent;
+exports.createPolicyEvent = createPolicyEvent;
+exports.createPromptInputEvent = createPromptInputEvent;
+exports.createRagRetrievalEvent = createRagRetrievalEvent;
+exports.createSessionEvent = createSessionEvent;
 exports.createSystemTelemetryEvent = createSystemTelemetryEvent;
+exports.createToolCallEvent = createToolCallEvent;
 exports.createTransactionEvent = createTransactionEvent;
+exports.createUserFeedbackEvent = createUserFeedbackEvent;
+exports.createWorkflowActionEvent = createWorkflowActionEvent;
 exports.parseQatiConfig = parseQatiConfig;
 exports.resolveQatiConfig = resolveQatiConfig;
 //# sourceMappingURL=index.cjs.map