@cat-factory/contracts 0.34.0 → 0.35.0

package/dist/routes/pipelines.d.ts

@@ -0,0 +1,457 @@
+import { ContractNoBody } from '@toad-contracts/valibot';
+import * as v from 'valibot';
+export declare const listPipelinesContract: {
+    readonly method: "get";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.StringSchema<undefined>;
+            readonly agentKinds: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+            readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+                readonly participants: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly role: v.StringSchema<undefined>;
+                    readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+                readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                    readonly enabled: v.BooleanSchema<undefined>;
+                    readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+                }, undefined>, undefined>;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly followUps: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly labels: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly archived: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly builtin: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    };
+};
+export declare const createPipelineContract: {
+    readonly method: "post";
+    readonly pathResolver: () => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
+        readonly agentKinds: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+        readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+        readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+        readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+        readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+            readonly enabled: v.BooleanSchema<undefined>;
+            readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+            readonly participants: v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.StringSchema<undefined>;
+                readonly role: v.StringSchema<undefined>;
+                readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+            readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>, undefined>, undefined>;
+        readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+            readonly enabled: v.BooleanSchema<undefined>;
+            readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+        }, undefined>, undefined>, undefined>, undefined>;
+        readonly labels: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 40, undefined>]>, undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 201: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.StringSchema<undefined>;
+            readonly agentKinds: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+            readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+                readonly participants: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly role: v.StringSchema<undefined>;
+                    readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+                readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                    readonly enabled: v.BooleanSchema<undefined>;
+                    readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+                }, undefined>, undefined>;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly followUps: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly labels: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly archived: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly builtin: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+export declare const clonePipelineContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        readonly pipelineId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
+    readonly pathResolver: ({ pipelineId }: {
+        pipelineId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 201: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.StringSchema<undefined>;
+            readonly agentKinds: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+            readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+                readonly participants: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly role: v.StringSchema<undefined>;
+                    readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+                readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                    readonly enabled: v.BooleanSchema<undefined>;
+                    readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+                }, undefined>, undefined>;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly followUps: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly labels: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly archived: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly builtin: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+export declare const updatePipelineContract: {
+    readonly method: "patch";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        readonly pipelineId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
+    readonly pathResolver: ({ pipelineId }: {
+        pipelineId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>, undefined>;
+        readonly agentKinds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>, undefined>;
+        readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+        readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+        readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+        readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+            readonly enabled: v.BooleanSchema<undefined>;
+            readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+            readonly participants: v.ArraySchema<v.ObjectSchema<{
+                readonly id: v.StringSchema<undefined>;
+                readonly role: v.StringSchema<undefined>;
+                readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+            readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>, undefined>, undefined>;
+        readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+            readonly enabled: v.BooleanSchema<undefined>;
+            readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+        }, undefined>, undefined>, undefined>, undefined>;
+        readonly labels: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 40, undefined>]>, undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.StringSchema<undefined>;
+            readonly agentKinds: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+            readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+                readonly participants: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly role: v.StringSchema<undefined>;
+                    readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+                readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                    readonly enabled: v.BooleanSchema<undefined>;
+                    readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+                }, undefined>, undefined>;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly followUps: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly labels: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly archived: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly builtin: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+export declare const organizePipelineContract: {
+    readonly method: "patch";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        readonly pipelineId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
+    readonly pathResolver: ({ pipelineId }: {
+        pipelineId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly labels: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 40, undefined>]>, undefined>, undefined>;
+        readonly archived: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly name: v.StringSchema<undefined>;
+            readonly agentKinds: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly gates: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly thresholds: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>, undefined>, undefined>;
+            readonly enabled: v.OptionalSchema<v.ArraySchema<v.BooleanSchema<undefined>, undefined>, undefined>;
+            readonly consensus: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
+                readonly participants: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly role: v.StringSchema<undefined>;
+                    readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
+                readonly gating: v.OptionalSchema<v.ObjectSchema<{
+                    readonly enabled: v.BooleanSchema<undefined>;
+                    readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                    readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
+                }, undefined>, undefined>;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly gating: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.ObjectSchema<{
+                readonly enabled: v.BooleanSchema<undefined>;
+                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
+            }, undefined>, undefined>, undefined>, undefined>;
+            readonly followUps: v.OptionalSchema<v.ArraySchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>, undefined>;
+            readonly labels: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly archived: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly builtin: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+export declare const deletePipelineContract: {
+    readonly method: "delete";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        readonly pipelineId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
+    readonly pathResolver: ({ pipelineId }: {
+        pipelineId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 204: typeof ContractNoBody;
+    };
+};
+//# sourceMappingURL=pipelines.d.ts.map

package/dist/routes/pipelines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../src/routes/pipelines.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAmB5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMhC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMjC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjC,CAAA"}

package/dist/routes/pipelines.js

@@ -0,0 +1,51 @@
+import { ContractNoBody, defineApiContract, withObjectKeys } from '@toad-contracts/valibot';
+import * as v from 'valibot';
+import { pipelineSchema } from '../entities.js';
+import { clonePipelineSchema, createPipelineSchema, organizePipelineSchema, updatePipelineSchema, } from '../requests.js';
+import { errorResponses } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Pipeline palette CRUD route contracts. Mounted under `/workspaces/:workspaceId`,
+// so the paths here are relative to that prefix. See PipelineController in
+// @cat-factory/server.
+// ---------------------------------------------------------------------------
+const pipelineListSchema = v.array(pipelineSchema);
+const pipelineIdParams = withObjectKeys(v.object({ pipelineId: v.string() }));
+export const listPipelinesContract = defineApiContract({
+    method: 'get',
+    pathResolver: () => '/pipelines',
+    responsesByStatusCode: { 200: pipelineListSchema, ...errorResponses },
+});
+export const createPipelineContract = defineApiContract({
+    method: 'post',
+    pathResolver: () => '/pipelines',
+    requestBodySchema: createPipelineSchema,
+    responsesByStatusCode: { 201: pipelineSchema, ...errorResponses },
+});
+export const clonePipelineContract = defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: pipelineIdParams,
+    pathResolver: ({ pipelineId }) => `/pipelines/${pipelineId}/clone`,
+    requestBodySchema: clonePipelineSchema,
+    responsesByStatusCode: { 201: pipelineSchema, ...errorResponses },
+});
+export const updatePipelineContract = defineApiContract({
+    method: 'patch',
+    requestPathParamsSchema: pipelineIdParams,
+    pathResolver: ({ pipelineId }) => `/pipelines/${pipelineId}`,
+    requestBodySchema: updatePipelineSchema,
+    responsesByStatusCode: { 200: pipelineSchema, ...errorResponses },
+});
+export const organizePipelineContract = defineApiContract({
+    method: 'patch',
+    requestPathParamsSchema: pipelineIdParams,
+    pathResolver: ({ pipelineId }) => `/pipelines/${pipelineId}/organize`,
+    requestBodySchema: organizePipelineSchema,
+    responsesByStatusCode: { 200: pipelineSchema, ...errorResponses },
+});
+export const deletePipelineContract = defineApiContract({
+    method: 'delete',
+    requestPathParamsSchema: pipelineIdParams,
+    pathResolver: ({ pipelineId }) => `/pipelines/${pipelineId}`,
+    responsesByStatusCode: { 204: ContractNoBody, ...errorResponses },
+});
+//# sourceMappingURL=pipelines.js.map

package/dist/routes/pipelines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipelines.js","sourceRoot":"","sources":["../../src/routes/pipelines.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,8EAA8E;AAC9E,mFAAmF;AACnF,2EAA2E;AAC3E,uBAAuB;AACvB,8EAA8E;AAE9E,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAA;AAClD,MAAM,gBAAgB,GAAG,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAA;AAE7E,MAAM,CAAC,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;IACrD,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,YAAY;IAChC,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAC;IACtD,MAAM,EAAE,MAAM;IACd,YAAY,EAAE,GAAG,EAAE,CAAC,YAAY;IAChC,iBAAiB,EAAE,oBAAoB;IACvC,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;IACrD,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,gBAAgB;IACzC,YAAY,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,cAAc,UAAU,QAAQ;IAClE,iBAAiB,EAAE,mBAAmB;IACtC,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAC;IACtD,MAAM,EAAE,OAAO;IACf,uBAAuB,EAAE,gBAAgB;IACzC,YAAY,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,cAAc,UAAU,EAAE;IAC5D,iBAAiB,EAAE,oBAAoB;IACvC,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,iBAAiB,CAAC;IACxD,MAAM,EAAE,OAAO;IACf,uBAAuB,EAAE,gBAAgB;IACzC,YAAY,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,cAAc,UAAU,WAAW;IACrE,iBAAiB,EAAE,sBAAsB;IACzC,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAC;IACtD,MAAM,EAAE,QAAQ;IAChB,uBAAuB,EAAE,gBAAgB;IACzC,YAAY,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,cAAc,UAAU,EAAE;IAC5D,qBAAqB,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE;CAClE,CAAC,CAAA"}

package/dist/routes/prompt-fragments.d.ts

@@ -0,0 +1,52 @@
+export declare const listFragmentCatalogContract: {
+    readonly method: "get";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly id: import("valibot").StringSchema<undefined>;
+            readonly version: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly category: import("valibot").StringSchema<undefined>;
+            readonly summary: import("valibot").StringSchema<undefined>;
+            readonly body: import("valibot").StringSchema<undefined>;
+            readonly appliesTo: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly blockTypes: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").PicklistSchema<["frontend", "service", "api", "database", "queue", "integration", "external", "environment"], undefined>, undefined>, undefined>;
+                readonly agentKinds: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>, undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly tags: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+            readonly source: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly sourceId: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly sha: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly documentRef: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github"], undefined>;
+                readonly externalId: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly resolvedAt: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    };
+};
+//# sourceMappingURL=prompt-fragments.d.ts.map

package/dist/routes/prompt-fragments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-fragments.d.ts","sourceRoot":"","sources":["../../src/routes/prompt-fragments.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAItC,CAAA"}

package/dist/routes/prompt-fragments.js

@@ -0,0 +1,14 @@
+import { defineApiContract } from '@toad-contracts/valibot';
+import { promptFragmentCatalogSchema } from '../entities.js';
+import { errorResponses } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Universal prompt-fragment catalog route contract. Workspace-independent and
+// cacheable, served read-only at the root. See PromptFragmentController in
+// @cat-factory/server.
+// ---------------------------------------------------------------------------
+export const listFragmentCatalogContract = defineApiContract({
+    method: 'get',
+    pathResolver: () => '/prompt-fragments',
+    responsesByStatusCode: { 200: promptFragmentCatalogSchema, ...errorResponses },
+});
+//# sourceMappingURL=prompt-fragments.js.map

package/dist/routes/prompt-fragments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-fragments.js","sourceRoot":"","sources":["../../src/routes/prompt-fragments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,8EAA8E;AAC9E,8EAA8E;AAC9E,2EAA2E;AAC3E,uBAAuB;AACvB,8EAA8E;AAE9E,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;IAC3D,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,mBAAmB;IACvC,qBAAqB,EAAE,EAAE,GAAG,EAAE,2BAA2B,EAAE,GAAG,cAAc,EAAE;CAC/E,CAAC,CAAA"}