@gera2ld/pb-datacenter 0.0.20 → 0.0.21

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./capabilities";
 export * from "./common";
 export * from "./pocketbase";
 export * from "./providers";
-export * from "./souls";
+export * from "./tokens";

package/dist/index.js

@@ -1,53 +1,39 @@
-import { asyncMemo as e } from "@gera2ld/async-memo";
-import { z as t } from "zod";
+import e, { z as t } from "zod";
 import { once as n, pick as r } from "es-toolkit";
 import i from "pocketbase";
+import { asyncMemo as a } from "@gera2ld/async-memo";
 //#region src/common.ts
-var a = t.looseObject({
+var o = t.looseObject({
 	type: t.literal("object"),
 	properties: t.record(t.string(), t.unknown()),
 	required: t.string().array().optional()
-}), o = t.union([t.object({
+}), s = t.union([t.object({
 	type: t.enum(["object", "array"]),
 	description: t.string().optional(),
-	schema: a
+	schema: o
 }), t.object({
 	type: t.literal("choice"),
 	description: t.string().optional(),
 	options: t.string().array()
-})]), s = t.object({
+})]), c = t.object({
 	maxOutputTokens: t.coerce.number(),
 	temperature: t.coerce.number()
-}).partial(), c = [
+}).partial(), l = [
 	"POCKETBASE_URL",
 	"POCKETBASE_ADMIN_USER",
 	"POCKETBASE_ADMIN_PASS"
-], l = r(process.env, c);
-function u(e) {
-	c.forEach((t) => {
-		e[t] != null && (l[t] = e[t]);
+], u = r(process.env, l);
+function d(e) {
+	l.forEach((t) => {
+		e[t] != null && (u[t] = e[t]);
 	});
 }
-var d = n(async function() {
-	let e = c.filter((e) => !l[e]);
+var f = n(async function() {
+	let e = l.filter((e) => !u[e]);
 	if (e.length) throw Error(`Missing env keys: ${e.join(", ")}`);
-	let { POCKETBASE_URL: t, POCKETBASE_ADMIN_USER: n, POCKETBASE_ADMIN_PASS: r } = l, a = new i(t).autoCancellation(!1);
+	let { POCKETBASE_URL: t, POCKETBASE_ADMIN_USER: n, POCKETBASE_ADMIN_PASS: r } = u, a = new i(t).autoCancellation(!1);
 	return await a.collection("_superusers").authWithPassword(n, r, { autoRefreshThreshold: 1800 }), a;
-}), f = t.object({
-	name: t.string(),
-	category: t.enum(["mode", "tool"]).catch("tool"),
-	phase: t.enum(["plan", "respond"]).catch("plan"),
-	description: t.string(),
-	triggerHint: t.string(),
-	alwaysActive: t.boolean(),
-	threshold: t.number(),
-	presentationPrompt: t.string().nullish(),
-	inputSchema: a.nullish()
-});
-async function p() {
-	return (await (await d()).collection("ai_capabilities").getFullList()).map((e) => f.parse(e));
-}
-var m = e(p, { ttl: 6e4 }), h = t.object({
+}), p = t.object({
 	name: t.string(),
 	enabled: t.boolean(),
 	handler: t.string(),
@@ -58,34 +44,25 @@ var m = e(p, { ttl: 6e4 }), h = t.object({
 	}).partial().nullish(),
 	options: t.record(t.string(), t.any()).nullish()
 });
-async function g(e) {
-	let t = await d(), n = await t.collection("ai_providers").getFirstListItem(t.filter("name={:name}", { name: e }));
-	return h.parse(n);
+async function m(e) {
+	let t = await f(), n = await t.collection("ai_providers").getFirstListItem(t.filter("name={:name}", { name: e }));
+	return p.parse(n);
 }
-var _ = e(g, {
+var h = a(m, {
 	ttl: 6e4,
 	resolver: (e) => e
-}), v = t.object({
-	id: t.string(),
-	name: t.string(),
-	basePrompt: t.string(),
-	presentationPrompt: t.string(),
-	providers: t.string().array().min(1),
-	outputSchema: o.nullish(),
-	overrideOptions: s.nullish(),
-	capabilities: t.string().array(),
-	expand: t.object({
-		providers: h.array().min(1),
-		capabilities: f.array().optional()
-	})
+}), g = e.object({
+	id: e.string(),
+	name: e.string(),
+	token: e.string(),
+	user: e.string().nullish(),
+	payload: e.unknown(),
+	created: e.string(),
+	updated: e.string()
 });
-async function y(e) {
-	let t = await d(), n = await t.collection("ai_souls").getFirstListItem(t.filter("name={:name}", { name: e }), { expand: "providers,capabilities" });
-	return v.parse(n);
+async function _(e) {
+	let t = await f(), n = t.filter(Object.keys(e).filter((t) => e[t]).map((e) => `${e} = {:${e}}`).join(" && "), e);
+	return await t.collection("tokens").getFirstListItem(n);
 }
-var b = e(y, {
-	ttl: 6e4,
-	resolver: (e) => e
-});
 //#endregion
-export { m as cachedFetchCapabilities, _ as cachedFetchProvider, b as cachedFetchSoul, f as capabilitySchema, p as fetchCapabilities, g as fetchProvider, y as fetchSoul, d as getPb, a as jsonSchema, o as outputSchema, s as overrideOptionsSchema, h as providerSchema, u as setPocketBaseEnv, v as soulSchema };
+export { h as cachedFetchProvider, m as fetchProvider, _ as findToken, f as getPb, o as jsonSchema, s as outputSchema, c as overrideOptionsSchema, p as providerSchema, d as setPocketBaseEnv, g as tokenRecordSchema };

package/dist/tokens.d.ts

@@ -0,0 +1,23 @@
+import z from "zod";
+export declare const tokenRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    token: z.ZodString;
+    user: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    payload: z.ZodUnknown;
+    created: z.ZodString;
+    updated: z.ZodString;
+}, z.core.$strip>;
+export type TokenRecord = z.infer<typeof tokenRecordSchema>;
+export declare function findToken(filters: {
+    token?: string;
+    user?: string;
+}): Promise<{
+    id: string;
+    name: string;
+    token: string;
+    payload: unknown;
+    created: string;
+    updated: string;
+    user?: string | null | undefined;
+}>;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@gera2ld/pb-datacenter",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "import": "./dist/index.js",

package/dist/capabilities.d.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-export declare const capabilitySchema: z.ZodObject<{
-    name: z.ZodString;
-    category: z.ZodCatch<z.ZodEnum<{
-        mode: "mode";
-        tool: "tool";
-    }>>;
-    phase: z.ZodCatch<z.ZodEnum<{
-        plan: "plan";
-        respond: "respond";
-    }>>;
-    description: z.ZodString;
-    triggerHint: z.ZodString;
-    alwaysActive: z.ZodBoolean;
-    threshold: z.ZodNumber;
-    presentationPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    inputSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$loose>>>;
-}, z.core.$strip>;
-export type CapabilitySchema = z.infer<typeof capabilitySchema>;
-export declare function fetchCapabilities(): Promise<{
-    name: string;
-    category: "mode" | "tool";
-    phase: "plan" | "respond";
-    description: string;
-    triggerHint: string;
-    alwaysActive: boolean;
-    threshold: number;
-    presentationPrompt?: string | null | undefined;
-    inputSchema?: {
-        [x: string]: unknown;
-        type: "object";
-        properties: Record<string, unknown>;
-        required?: string[] | undefined;
-    } | null | undefined;
-}[]>;
-export declare const cachedFetchCapabilities: import("@gera2ld/async-memo").CachedFunction<[], {
-    name: string;
-    category: "mode" | "tool";
-    phase: "plan" | "respond";
-    description: string;
-    triggerHint: string;
-    alwaysActive: boolean;
-    threshold: number;
-    presentationPrompt?: string | null | undefined;
-    inputSchema?: {
-        [x: string]: unknown;
-        type: "object";
-        properties: Record<string, unknown>;
-        required?: string[] | undefined;
-    } | null | undefined;
-}[], Map<string, import("@gera2ld/async-memo").CacheData<unknown>>>;

package/dist/souls.d.ts

@@ -1,180 +0,0 @@
-import { z } from "zod";
-export declare const soulSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    basePrompt: z.ZodString;
-    presentationPrompt: z.ZodString;
-    providers: z.ZodArray<z.ZodString>;
-    outputSchema: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodEnum<{
-            object: "object";
-            array: "array";
-        }>;
-        description: z.ZodOptional<z.ZodString>;
-        schema: z.ZodObject<{
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$loose>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"choice">;
-        description: z.ZodOptional<z.ZodString>;
-        options: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>]>>>;
-    overrideOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        maxOutputTokens: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        temperature: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    }, z.core.$strip>>>;
-    capabilities: z.ZodArray<z.ZodString>;
-    expand: z.ZodObject<{
-        providers: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            enabled: z.ZodBoolean;
-            handler: z.ZodString;
-            model: z.ZodString;
-            metadata: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                price: z.ZodOptional<z.ZodNumber>;
-                image: z.ZodOptional<z.ZodObject<{
-                    single: z.ZodOptional<z.ZodBoolean>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>>;
-            options: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
-        }, z.core.$strip>>;
-        capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            category: z.ZodCatch<z.ZodEnum<{
-                mode: "mode";
-                tool: "tool";
-            }>>;
-            phase: z.ZodCatch<z.ZodEnum<{
-                plan: "plan";
-                respond: "respond";
-            }>>;
-            description: z.ZodString;
-            triggerHint: z.ZodString;
-            alwaysActive: z.ZodBoolean;
-            threshold: z.ZodNumber;
-            presentationPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            inputSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                type: z.ZodLiteral<"object">;
-                properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                required: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$loose>>>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type SoulSchema = z.infer<typeof soulSchema>;
-export declare function fetchSoul(name: string): Promise<{
-    id: string;
-    name: string;
-    basePrompt: string;
-    presentationPrompt: string;
-    providers: string[];
-    capabilities: string[];
-    expand: {
-        providers: {
-            name: string;
-            enabled: boolean;
-            handler: string;
-            model: string;
-            metadata?: {
-                price?: number | undefined;
-                image?: {
-                    single?: boolean | undefined;
-                } | undefined;
-            } | null | undefined;
-            options?: Record<string, any> | null | undefined;
-        }[];
-        capabilities?: {
-            name: string;
-            category: "mode" | "tool";
-            phase: "plan" | "respond";
-            description: string;
-            triggerHint: string;
-            alwaysActive: boolean;
-            threshold: number;
-            presentationPrompt?: string | null | undefined;
-            inputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties: Record<string, unknown>;
-                required?: string[] | undefined;
-            } | null | undefined;
-        }[] | undefined;
-    };
-    outputSchema?: {
-        type: "object" | "array";
-        schema: {
-            [x: string]: unknown;
-            type: "object";
-            properties: Record<string, unknown>;
-            required?: string[] | undefined;
-        };
-        description?: string | undefined;
-    } | {
-        type: "choice";
-        options: string[];
-        description?: string | undefined;
-    } | null | undefined;
-    overrideOptions?: {
-        maxOutputTokens?: number | undefined;
-        temperature?: number | undefined;
-    } | null | undefined;
-}>;
-export declare const cachedFetchSoul: import("@gera2ld/async-memo").CachedFunction<[name: string], {
-    id: string;
-    name: string;
-    basePrompt: string;
-    presentationPrompt: string;
-    providers: string[];
-    capabilities: string[];
-    expand: {
-        providers: {
-            name: string;
-            enabled: boolean;
-            handler: string;
-            model: string;
-            metadata?: {
-                price?: number | undefined;
-                image?: {
-                    single?: boolean | undefined;
-                } | undefined;
-            } | null | undefined;
-            options?: Record<string, any> | null | undefined;
-        }[];
-        capabilities?: {
-            name: string;
-            category: "mode" | "tool";
-            phase: "plan" | "respond";
-            description: string;
-            triggerHint: string;
-            alwaysActive: boolean;
-            threshold: number;
-            presentationPrompt?: string | null | undefined;
-            inputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties: Record<string, unknown>;
-                required?: string[] | undefined;
-            } | null | undefined;
-        }[] | undefined;
-    };
-    outputSchema?: {
-        type: "object" | "array";
-        schema: {
-            [x: string]: unknown;
-            type: "object";
-            properties: Record<string, unknown>;
-            required?: string[] | undefined;
-        };
-        description?: string | undefined;
-    } | {
-        type: "choice";
-        options: string[];
-        description?: string | undefined;
-    } | null | undefined;
-    overrideOptions?: {
-        maxOutputTokens?: number | undefined;
-        temperature?: number | undefined;
-    } | null | undefined;
-}, Map<string, import("@gera2ld/async-memo").CacheData<unknown>>>;