@handlebar/governance-schema 0.0.6-dev.6 → 0.0.6-dev.8

package/dist/rules/signals.d.ts

@@ -1,44 +1,79 @@
-import type { JSONValue } from "./common";
-import type { RuleEffectKind } from "./effects";
-/**
- * Requires the existence of subject data at runtime.
- *
- * Handlebar is agnostic to the source of the data,
- * so long as it is present in the engine runtime.
- */
-export type RequireSubjectCondition = {
-    kind: "requireSubject";
-    subjectType: string;
-    idSystem?: string;
-};
-type SignalBinding = {
-    from: "endUserId";
-} | {
-    from: "endUserTag";
-    tag: string;
-} | {
-    from: "toolName";
-} | {
-    from: "toolTag";
-    tag: string;
-} | {
-    from: "toolArg";
-    path: string;
-} | {
-    from: "subject";
-    subjectType: string;
-    role?: string;
-    field?: "id" | "idSystem";
-} | {
-    from: "const";
-    value: JSONValue;
-};
-export type SignalCondition = {
-    kind: "signal";
-    key: string;
-    args: Record<string, SignalBinding>;
-    op: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin";
-    value: JSONValue;
-    onMissing?: RuleEffectKind;
-};
-export {};
+import { z } from "zod";
+export declare const RequireSubjectConditionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"requireSubject">;
+    subjectType: z.ZodString;
+    idSystem: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RequireSubjectCondition = z.infer<typeof RequireSubjectConditionSchema>;
+export declare const SignalBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    from: z.ZodLiteral<"enduserId">;
+}, z.core.$strict>, z.ZodObject<{
+    from: z.ZodLiteral<"enduserTag">;
+    tag: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    from: z.ZodLiteral<"toolName">;
+}, z.core.$strict>, z.ZodObject<{
+    from: z.ZodLiteral<"toolTag">;
+    tag: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    from: z.ZodLiteral<"toolArg">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    from: z.ZodLiteral<"subject">;
+    subjectType: z.ZodString;
+    role: z.ZodOptional<z.ZodString>;
+    field: z.ZodOptional<z.ZodEnum<{
+        idSystem: "idSystem";
+        id: "id";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    from: z.ZodLiteral<"const">;
+    value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+}, z.core.$strict>], "from">;
+export type SignalBinding = z.infer<typeof SignalBindingSchema>;
+export declare const SignalConditionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"signal">;
+    key: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        from: z.ZodLiteral<"enduserId">;
+    }, z.core.$strict>, z.ZodObject<{
+        from: z.ZodLiteral<"enduserTag">;
+        tag: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        from: z.ZodLiteral<"toolName">;
+    }, z.core.$strict>, z.ZodObject<{
+        from: z.ZodLiteral<"toolTag">;
+        tag: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        from: z.ZodLiteral<"toolArg">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        from: z.ZodLiteral<"subject">;
+        subjectType: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        field: z.ZodOptional<z.ZodEnum<{
+            idSystem: "idSystem";
+            id: "id";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        from: z.ZodLiteral<"const">;
+        value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+    }, z.core.$strict>], "from">>;
+    op: z.ZodEnum<{
+        in: "in";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+        neq: "neq";
+        nin: "nin";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>;
+    onMissing: z.ZodOptional<z.ZodEnum<{
+        allow: "allow";
+        block: "block";
+        hitl: "hitl";
+    }>>;
+}, z.core.$strict>;
+export type SignalCondition = z.infer<typeof SignalConditionSchema>;

package/dist/rules/time.d.ts

@@ -1,28 +1,56 @@
-export type TimeGateCondition = {
-    kind: "timeGate";
-    timezone: {
-        source: "endUserTag";
-        tag: string;
-        fallback?: "org";
-    };
-    windows: Array<{
-        days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
-        start: string;
-        end: string;
+import { z } from "zod";
+declare const DaySchema: z.ZodEnum<{
+    mon: "mon";
+    tue: "tue";
+    wed: "wed";
+    thu: "thu";
+    fri: "fri";
+    sat: "sat";
+    sun: "sun";
+}>;
+export type Day = z.infer<typeof DaySchema>;
+export declare const TimeGateConditionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"timeGate">;
+    timezone: z.ZodObject<{
+        source: z.ZodLiteral<"enduserTag">;
+        tag: z.ZodString;
+        fallback: z.ZodOptional<z.ZodLiteral<"org">>;
+    }, z.core.$strict>;
+    windows: z.ZodArray<z.ZodObject<{
+        days: z.ZodArray<z.ZodEnum<{
+            mon: "mon";
+            tue: "tue";
+            wed: "wed";
+            thu: "thu";
+            fri: "fri";
+            sat: "sat";
+            sun: "sun";
+        }>>;
+        start: z.ZodString;
+        end: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TimeGateCondition = z.infer<typeof TimeGateConditionSchema>;
+declare const ExecutionTimeScopeSchema: z.ZodEnum<{
+    tool: "tool";
+    total: "total";
+}>;
+export type ExecutionTimeScope = z.infer<typeof ExecutionTimeScopeSchema>;
+export declare const ExecutionTimeConditionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"executionTime">;
+    scope: z.ZodEnum<{
+        tool: "tool";
+        total: "total";
     }>;
-};
-/**
- * Scope for execution time measurement.
- * - "tool": the single tool call duration
- * - "total": end-to-end agent run (from start to now)
- */
-export type ExecutionTimeScope = "tool" | "total";
-/**
- * Match against execution time thresholds (milliseconds).
- */
-export type ExecutionTimeCondition = {
-    kind: "executionTime";
-    scope: ExecutionTimeScope;
-    op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
-    ms: number;
-};
+    op: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+        neq: "neq";
+    }>;
+    ms: z.ZodNumber;
+}, z.core.$strict>;
+export type ExecutionTimeCondition = z.infer<typeof ExecutionTimeConditionSchema>;
+export {};

package/dist/rules/tools.d.ts

@@ -1,64 +1,58 @@
-import type { Glob } from "./common";
-/**
- * Match on a tool's name.
- * - glob comparator supports wildcard matching
- * - in comparator permits list membership check
- */
-export type ToolNameCondition = {
-    kind: "toolName";
-    op: "eq" | "neq" | "contains" | "startsWith" | "endsWith" | "glob";
-    value: string | Glob;
-} | {
-    kind: "toolName";
-    op: "in";
-    value: (string | Glob)[];
-};
-/**
- * Match on tool tags present on the tool.
- * - has: single tag must be present
- * - anyOf: at least one tag present
- * - allOf: every provided tag must be present
- */
-export type ToolTagCondition = {
-    kind: "toolTag";
-    op: "has";
-    tag: string;
-} | {
-    kind: "toolTag";
-    op: "anyOf";
-    tags: string[];
-} | {
-    kind: "toolTag";
-    op: "allOf";
-    tags: string[];
-};
-/**
-* Enforce sequencing constraints within the current run history.
-* - mustHaveCalled: all listed tool name patterns must have been called earlier
-* - mustNotHaveCalled: none of the listed patterns may have been called earlier
-*/
-export type SequenceCondition = {
-    kind: "sequence";
-    mustHaveCalled?: Glob[];
-    mustNotHaveCalled?: Glob[];
-};
-/**
- * Select tools for counting within a run.
- * - by toolName: count calls whose name matches any provided glob patterns
- * - by toolTag: count calls whose tool includes any of the provided tags
- */
-export type MaxCallsSelector = {
-    by: "toolName";
-    patterns: Glob[];
-} | {
-    by: "toolTag";
-    tags: string[];
-};
-/**
- * Assert a maximum number of calls within a run for the selected tools (inclusive).
- */
-export type MaxCallsCondition = {
-    kind: "maxCalls";
-    selector: MaxCallsSelector;
-    max: number;
-};
+import { z } from "zod";
+export declare const ToolNameConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"toolName">;
+    op: z.ZodEnum<{
+        eq: "eq";
+        neq: "neq";
+        contains: "contains";
+        startsWith: "startsWith";
+        endsWith: "endsWith";
+        glob: "glob";
+    }>;
+    value: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"toolName">;
+    op: z.ZodLiteral<"in">;
+    value: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "op">;
+export type ToolNameCondition = z.infer<typeof ToolNameConditionSchema>;
+export declare const ToolTagConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"toolTag">;
+    op: z.ZodLiteral<"has">;
+    tag: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"toolTag">;
+    op: z.ZodLiteral<"anyOf">;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"toolTag">;
+    op: z.ZodLiteral<"allOf">;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "op">;
+export type ToolTagCondition = z.infer<typeof ToolTagConditionSchema>;
+export declare const SequenceConditionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"sequence">;
+    mustHaveCalled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mustNotHaveCalled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SequenceCondition = z.infer<typeof SequenceConditionSchema>;
+export declare const MaxCallsSelectorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    by: z.ZodLiteral<"toolName">;
+    patterns: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    by: z.ZodLiteral<"toolTag">;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "by">;
+export type MaxCallsSelector = z.infer<typeof MaxCallsSelectorSchema>;
+export declare const MaxCallsConditionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"maxCalls">;
+    selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        by: z.ZodLiteral<"toolName">;
+        patterns: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        by: z.ZodLiteral<"toolTag">;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "by">;
+    max: z.ZodNumber;
+}, z.core.$strict>;
+export type MaxCallsCondition = z.infer<typeof MaxCallsConditionSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@handlebar/governance-schema",
-	"version": "0.0.6-dev.6",
+	"version": "0.0.6-dev.8",
 	"private": false,
 	"type": "module",
 	"main": "./dist/index.cjs",