@cat-factory/contracts 0.35.0 → 0.37.0

package/dist/routes/models.d.ts

@@ -1,121 +1,120 @@
-import * as v from 'valibot';
 export declare const listModelsContract: {
     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>;
+        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': 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>;
+        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: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly label: v.StringSchema<undefined>;
-            readonly description: v.StringSchema<undefined>;
-            readonly flavor: v.PicklistSchema<["cloudflare", "direct", "openrouter", "subscription"], undefined>;
-            readonly available: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly providerLabel: v.StringSchema<undefined>;
-            readonly provider: v.StringSchema<undefined>;
-            readonly model: v.StringSchema<undefined>;
-            readonly vendor: v.OptionalSchema<v.PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>, undefined>;
-            readonly cost: v.OptionalSchema<v.ObjectSchema<{
-                readonly inputPerMillion: v.NumberSchema<undefined>;
-                readonly outputPerMillion: v.NumberSchema<undefined>;
-                readonly currency: v.StringSchema<undefined>;
+        readonly 200: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly id: import("valibot").StringSchema<undefined>;
+            readonly label: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly flavor: import("valibot").PicklistSchema<["cloudflare", "direct", "openrouter", "subscription"], undefined>;
+            readonly available: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+            readonly providerLabel: import("valibot").StringSchema<undefined>;
+            readonly provider: import("valibot").StringSchema<undefined>;
+            readonly model: import("valibot").StringSchema<undefined>;
+            readonly vendor: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>, undefined>;
+            readonly cost: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly currency: import("valibot").StringSchema<undefined>;
             }, undefined>, undefined>;
-            readonly contextTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly quotaBased: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly subscription: v.OptionalSchema<v.ObjectSchema<{
-                readonly vendor: v.PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>;
-                readonly providerLabel: v.StringSchema<undefined>;
-                readonly provider: v.StringSchema<undefined>;
-                readonly model: v.StringSchema<undefined>;
-                readonly cost: v.OptionalSchema<v.ObjectSchema<{
-                    readonly inputPerMillion: v.NumberSchema<undefined>;
-                    readonly outputPerMillion: v.NumberSchema<undefined>;
-                    readonly currency: v.StringSchema<undefined>;
+            readonly contextTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            readonly quotaBased: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+            readonly subscription: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly vendor: import("valibot").PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>;
+                readonly providerLabel: import("valibot").StringSchema<undefined>;
+                readonly provider: import("valibot").StringSchema<undefined>;
+                readonly model: import("valibot").StringSchema<undefined>;
+                readonly cost: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                    readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                    readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
+                    readonly currency: import("valibot").StringSchema<undefined>;
                 }, undefined>, undefined>;
-                readonly contextTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+                readonly contextTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>, undefined>;
     };
 };
 export declare const listWorkspaceModelsContract: {
     readonly method: "get";
-    readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly workspaceId: v.StringSchema<undefined>;
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        workspaceId: import("valibot").StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ workspaceId }: {
         workspaceId: 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>;
+        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': 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>;
+        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: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly label: v.StringSchema<undefined>;
-            readonly description: v.StringSchema<undefined>;
-            readonly flavor: v.PicklistSchema<["cloudflare", "direct", "openrouter", "subscription"], undefined>;
-            readonly available: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly providerLabel: v.StringSchema<undefined>;
-            readonly provider: v.StringSchema<undefined>;
-            readonly model: v.StringSchema<undefined>;
-            readonly vendor: v.OptionalSchema<v.PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>, undefined>;
-            readonly cost: v.OptionalSchema<v.ObjectSchema<{
-                readonly inputPerMillion: v.NumberSchema<undefined>;
-                readonly outputPerMillion: v.NumberSchema<undefined>;
-                readonly currency: v.StringSchema<undefined>;
+        readonly 200: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly id: import("valibot").StringSchema<undefined>;
+            readonly label: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly flavor: import("valibot").PicklistSchema<["cloudflare", "direct", "openrouter", "subscription"], undefined>;
+            readonly available: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+            readonly providerLabel: import("valibot").StringSchema<undefined>;
+            readonly provider: import("valibot").StringSchema<undefined>;
+            readonly model: import("valibot").StringSchema<undefined>;
+            readonly vendor: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>, undefined>;
+            readonly cost: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly currency: import("valibot").StringSchema<undefined>;
             }, undefined>, undefined>;
-            readonly contextTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly quotaBased: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly subscription: v.OptionalSchema<v.ObjectSchema<{
-                readonly vendor: v.PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>;
-                readonly providerLabel: v.StringSchema<undefined>;
-                readonly provider: v.StringSchema<undefined>;
-                readonly model: v.StringSchema<undefined>;
-                readonly cost: v.OptionalSchema<v.ObjectSchema<{
-                    readonly inputPerMillion: v.NumberSchema<undefined>;
-                    readonly outputPerMillion: v.NumberSchema<undefined>;
-                    readonly currency: v.StringSchema<undefined>;
+            readonly contextTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            readonly quotaBased: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+            readonly subscription: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                readonly vendor: import("valibot").PicklistSchema<["claude", "codex", "glm", "kimi", "deepseek"], undefined>;
+                readonly providerLabel: import("valibot").StringSchema<undefined>;
+                readonly provider: import("valibot").StringSchema<undefined>;
+                readonly model: import("valibot").StringSchema<undefined>;
+                readonly cost: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+                    readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                    readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
+                    readonly currency: import("valibot").StringSchema<undefined>;
                 }, undefined>, undefined>;
-                readonly contextTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+                readonly contextTokens: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>, undefined>;
     };

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

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/routes/models.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI7B,CAAA;AAIF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtC,CAAA"}
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/routes/models.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI7B,CAAA;AAIF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtC,CAAA"}

package/dist/routes/models.js

@@ -1,13 +1,12 @@
-import { defineApiContract, withObjectKeys } from '@toad-contracts/valibot';
-import * as v from 'valibot';
+import { defineApiContract } from '@toad-contracts/valibot';
 import { modelCatalogSchema } from '../entities.js';
-import { errorResponses } from './_shared.js';
+import { errorResponses, singleStringParam } from './_shared.js';
 // ---------------------------------------------------------------------------
 // Model picker catalog route contracts. The ModelController is mounted at `/`,
 // so both paths are absolute and `workspaceId` IS a path param. See
 // ModelController in @cat-factory/server.
 // ---------------------------------------------------------------------------
-const workspaceIdParams = withObjectKeys(v.object({ workspaceId: v.string() }));
+const workspaceIdParams = singleStringParam('workspaceId');
 // Deployment-level catalog (no workspace context).
 export const listModelsContract = defineApiContract({
     method: 'get',

package/dist/routes/models.js.map

@@ -1 +1 @@
-{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/routes/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,8EAA8E;AAC9E,+EAA+E;AAC/E,oEAAoE;AACpE,0CAA0C;AAC1C,8EAA8E;AAE9E,MAAM,iBAAiB,GAAG,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAA;AAE/E,mDAAmD;AACnD,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;IAClD,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS;IAC7B,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA;AAEF,yFAAyF;AACzF,wFAAwF;AACxF,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;IAC3D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,SAAS;IACtE,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA"}
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/routes/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,+EAA+E;AAC/E,oEAAoE;AACpE,0CAA0C;AAC1C,8EAA8E;AAE9E,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAA;AAE1D,mDAAmD;AACnD,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;IAClD,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS;IAC7B,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA;AAEF,yFAAyF;AACzF,wFAAwF;AACxF,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;IAC3D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,SAAS;IACtE,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA"}

package/dist/routes/notifications.d.ts

@@ -69,7 +69,7 @@ export declare const listNotificationsContract: {
 export declare const actNotificationContract: {
     readonly method: "post";
     readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly notificationId: v.StringSchema<undefined>;
+        notificationId: v.StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ notificationId }: {
         notificationId: string;
@@ -141,7 +141,7 @@ export declare const actNotificationContract: {
 export declare const dismissNotificationContract: {
     readonly method: "post";
     readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly notificationId: v.StringSchema<undefined>;
+        notificationId: v.StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ notificationId }: {
         notificationId: string;

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

@@ -1 +1 @@
-{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../src/routes/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMtC,CAAA"}
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../src/routes/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIpC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMtC,CAAA"}

package/dist/routes/notifications.js

@@ -1,14 +1,14 @@
-import { ContractNoBody, defineApiContract, withObjectKeys } from '@toad-contracts/valibot';
+import { ContractNoBody, defineApiContract } from '@toad-contracts/valibot';
 import * as v from 'valibot';
 import { notificationSchema } from '../notifications.js';
-import { errorResponses } from './_shared.js';
+import { errorResponses, singleStringParam } from './_shared.js';
 // ---------------------------------------------------------------------------
 // Notification inbox route contracts. Mounted under `/workspaces/:workspaceId`,
 // so the paths here are relative to that prefix (the frontend supplies it via
 // `pathPrefix`, the backend via the controller's mount point).
 // ---------------------------------------------------------------------------
 const notificationListSchema = v.array(notificationSchema);
-const notificationIdParams = withObjectKeys(v.object({ notificationId: v.string() }));
+const notificationIdParams = singleStringParam('notificationId');
 export const listNotificationsContract = defineApiContract({
     method: 'get',
     pathResolver: () => '/notifications',

package/dist/routes/notifications.js.map

@@ -1 +1 @@
-{"version":3,"file":"notifications.js","sourceRoot":"","sources":["../../src/routes/notifications.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,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAC9E,+DAA+D;AAC/D,8EAA8E;AAE9E,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAA;AAC1D,MAAM,oBAAoB,GAAG,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAA;AAErF,MAAM,CAAC,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;IACzD,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,gBAAgB;IACpC,qBAAqB,EAAE,EAAE,GAAG,EAAE,sBAAsB,EAAE,GAAG,cAAc,EAAE;CAC1E,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,iBAAiB,CAAC;IACvD,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,oBAAoB;IAC7C,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,kBAAkB,cAAc,MAAM;IAC5E,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;IAC3D,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,oBAAoB;IAC7C,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,kBAAkB,cAAc,UAAU;IAChF,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA"}
+{"version":3,"file":"notifications.js","sourceRoot":"","sources":["../../src/routes/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAC9E,+DAA+D;AAC/D,8EAA8E;AAE9E,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAA;AAC1D,MAAM,oBAAoB,GAAG,iBAAiB,CAAC,gBAAgB,CAAC,CAAA;AAEhE,MAAM,CAAC,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;IACzD,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,gBAAgB;IACpC,qBAAqB,EAAE,EAAE,GAAG,EAAE,sBAAsB,EAAE,GAAG,cAAc,EAAE;CAC1E,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,iBAAiB,CAAC;IACvD,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,oBAAoB;IAC7C,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,kBAAkB,cAAc,MAAM;IAC5E,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,iBAAiB,CAAC;IAC3D,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,oBAAoB;IAC7C,YAAY,EAAE,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,kBAAkB,cAAc,UAAU;IAChF,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,cAAc,EAAE;CACtE,CAAC,CAAA"}

package/dist/routes/openrouter.d.ts

@@ -1,144 +1,143 @@
 import { ContractNoBody } from '@toad-contracts/valibot';
-import * as v from 'valibot';
 export declare const getOpenRouterCatalogContract: {
     readonly method: "get";
-    readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly workspaceId: v.StringSchema<undefined>;
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        workspaceId: import("valibot").StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ workspaceId }: {
         workspaceId: 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>;
+        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': 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>;
+        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: v.ObjectSchema<{
-            readonly models: v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly contextLength: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly inputPerMillion: v.NumberSchema<undefined>;
-                readonly outputPerMillion: v.NumberSchema<undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                readonly contextLength: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
             }, undefined>, undefined>;
-            readonly createdAt: v.NumberSchema<undefined>;
-            readonly updatedAt: v.NumberSchema<undefined>;
+            readonly createdAt: import("valibot").NumberSchema<undefined>;
+            readonly updatedAt: import("valibot").NumberSchema<undefined>;
         }, undefined>;
     };
 };
 export declare const upsertOpenRouterCatalogContract: {
     readonly method: "put";
-    readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly workspaceId: v.StringSchema<undefined>;
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        workspaceId: import("valibot").StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ workspaceId }: {
         workspaceId: string;
     }) => string;
-    readonly requestBodySchema: v.ObjectSchema<{
-        readonly models: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-            readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-            readonly contextLength: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly inputPerMillion: v.NumberSchema<undefined>;
-            readonly outputPerMillion: v.NumberSchema<undefined>;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+            readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+            readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+            readonly contextLength: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+            readonly outputPerMillion: import("valibot").NumberSchema<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>;
+        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': 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>;
+        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: v.ObjectSchema<{
-            readonly models: v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly contextLength: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly inputPerMillion: v.NumberSchema<undefined>;
-                readonly outputPerMillion: v.NumberSchema<undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                readonly contextLength: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
             }, undefined>, undefined>;
-            readonly createdAt: v.NumberSchema<undefined>;
-            readonly updatedAt: v.NumberSchema<undefined>;
+            readonly createdAt: import("valibot").NumberSchema<undefined>;
+            readonly updatedAt: import("valibot").NumberSchema<undefined>;
         }, undefined>;
     };
 };
 export declare const refreshOpenRouterCatalogContract: {
     readonly method: "post";
-    readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly workspaceId: v.StringSchema<undefined>;
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        workspaceId: import("valibot").StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ workspaceId }: {
         workspaceId: string;
     }) => string;
     readonly requestBodySchema: typeof ContractNoBody;
     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>;
+        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': 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>;
+        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: v.ObjectSchema<{
-            readonly reachable: v.BooleanSchema<undefined>;
-            readonly models: v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly contextLength: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly inputPerMillion: v.NumberSchema<undefined>;
-                readonly outputPerMillion: v.NumberSchema<undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly reachable: import("valibot").BooleanSchema<undefined>;
+            readonly models: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+                readonly contextLength: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly inputPerMillion: import("valibot").NumberSchema<undefined>;
+                readonly outputPerMillion: import("valibot").NumberSchema<undefined>;
             }, undefined>, undefined>;
-            readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly error: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
         }, undefined>;
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"openrouter.d.ts","sourceRoot":"","sources":["../../src/routes/openrouter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAiB5B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM1C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM3C,CAAA"}
+{"version":3,"file":"openrouter.d.ts","sourceRoot":"","sources":["../../src/routes/openrouter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAiB3E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM1C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM3C,CAAA"}

package/dist/routes/openrouter.js

@@ -1,14 +1,13 @@
-import { ContractNoBody, defineApiContract, withObjectKeys } from '@toad-contracts/valibot';
-import * as v from 'valibot';
+import { ContractNoBody, defineApiContract } from '@toad-contracts/valibot';
 import { openRouterCatalogSchema, openRouterRefreshResultSchema, upsertOpenRouterCatalogSchema, } from '../openrouter.js';
-import { errorResponses } from './_shared.js';
+import { errorResponses, singleStringParam } from './_shared.js';
 // ---------------------------------------------------------------------------
 // Per-workspace OpenRouter dynamic-catalog route contracts. The
 // OpenRouterCatalogController is mounted at `/`, so the paths are absolute and
 // `workspaceId` IS a path param. See OpenRouterCatalogController in
 // @cat-factory/server.
 // ---------------------------------------------------------------------------
-const workspaceIdParams = withObjectKeys(v.object({ workspaceId: v.string() }));
+const workspaceIdParams = singleStringParam('workspaceId');
 export const getOpenRouterCatalogContract = defineApiContract({
     method: 'get',
     requestPathParamsSchema: workspaceIdParams,

package/dist/routes/openrouter.js.map

@@ -1 +1 @@
-{"version":3,"file":"openrouter.js","sourceRoot":"","sources":["../../src/routes/openrouter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE7C,8EAA8E;AAC9E,gEAAgE;AAChE,+EAA+E;AAC/E,oEAAoE;AACpE,uBAAuB;AACvB,8EAA8E;AAE9E,MAAM,iBAAiB,GAAG,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAA;AAE/E,MAAM,CAAC,MAAM,4BAA4B,GAAG,iBAAiB,CAAC;IAC5D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,qBAAqB;IAClF,qBAAqB,EAAE,EAAE,GAAG,EAAE,uBAAuB,EAAE,GAAG,cAAc,EAAE;CAC3E,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,+BAA+B,GAAG,iBAAiB,CAAC;IAC/D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,qBAAqB;IAClF,iBAAiB,EAAE,6BAA6B;IAChD,qBAAqB,EAAE,EAAE,GAAG,EAAE,uBAAuB,EAAE,GAAG,cAAc,EAAE;CAC3E,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,iBAAiB,CAAC;IAChE,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,qBAAqB;IAClF,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,6BAA6B,EAAE,GAAG,cAAc,EAAE;CACjF,CAAC,CAAA"}
+{"version":3,"file":"openrouter.js","sourceRoot":"","sources":["../../src/routes/openrouter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3E,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,gEAAgE;AAChE,+EAA+E;AAC/E,oEAAoE;AACpE,uBAAuB;AACvB,8EAA8E;AAE9E,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAA;AAE1D,MAAM,CAAC,MAAM,4BAA4B,GAAG,iBAAiB,CAAC;IAC5D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,qBAAqB;IAClF,qBAAqB,EAAE,EAAE,GAAG,EAAE,uBAAuB,EAAE,GAAG,cAAc,EAAE;CAC3E,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,+BAA+B,GAAG,iBAAiB,CAAC;IAC/D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,qBAAqB;IAClF,iBAAiB,EAAE,6BAA6B;IAChD,qBAAqB,EAAE,EAAE,GAAG,EAAE,uBAAuB,EAAE,GAAG,cAAc,EAAE;CAC3E,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,iBAAiB,CAAC;IAChE,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,iBAAiB;IAC1C,YAAY,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,eAAe,WAAW,qBAAqB;IAClF,iBAAiB,EAAE,cAAc;IACjC,qBAAqB,EAAE,EAAE,GAAG,EAAE,6BAA6B,EAAE,GAAG,cAAc,EAAE;CACjF,CAAC,CAAA"}

package/dist/routes/personal-subscriptions.d.ts

@@ -90,7 +90,7 @@ export declare const storePersonalSubscriptionContract: {
 export declare const removePersonalSubscriptionContract: {
     readonly method: "delete";
     readonly requestPathParamsSchema: v.ObjectSchema<{
-        readonly vendor: v.StringSchema<undefined>;
+        vendor: v.StringSchema<undefined>;
     }, undefined> & import("@toad-contracts/core").ObjectKeysCarrier;
     readonly pathResolver: ({ vendor }: {
         vendor: string;

package/dist/routes/personal-subscriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"personal-subscriptions.d.ts","sourceRoot":"","sources":["../../src/routes/personal-subscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAoB5B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI5C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK5C,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7C,CAAA"}
+{"version":3,"file":"personal-subscriptions.d.ts","sourceRoot":"","sources":["../../src/routes/personal-subscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAoB5B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI5C,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK5C,CAAA;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7C,CAAA"}