@gera2ld/pb-datacenter 0.0.20 → 0.0.22

package/dist/capabilities.d.ts

@@ -10,9 +10,7 @@ export declare const capabilitySchema: z.ZodObject<{
         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">;
@@ -21,35 +19,3 @@ export declare const capabilitySchema: z.ZodObject<{
     }, 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/index.d.ts

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

package/dist/index.js

@@ -1,53 +1,47 @@
-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 = [
-	"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]);
-	});
-}
-var d = n(async function() {
-	let e = c.filter((e) => !l[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);
-	return await a.collection("_superusers").authWithPassword(n, r, { autoRefreshThreshold: 1800 }), a;
-}), f = t.object({
+}).partial(), l = 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));
+	inputSchema: o.nullish()
+}), u = [
+	"POCKETBASE_URL",
+	"POCKETBASE_ADMIN_USER",
+	"POCKETBASE_ADMIN_PASS"
+], d = r(process.env, u);
+function f(e) {
+	u.forEach((t) => {
+		e[t] != null && (d[t] = e[t]);
+	});
 }
-var m = e(p, { ttl: 6e4 }), h = t.object({
+var p = n(async function() {
+	let e = u.filter((e) => !d[e]);
+	if (e.length) throw Error(`Missing env keys: ${e.join(", ")}`);
+	let { POCKETBASE_URL: t, POCKETBASE_ADMIN_USER: n, POCKETBASE_ADMIN_PASS: r } = d, a = new i(t).autoCancellation(!1);
+	return await a.collection("_superusers").authWithPassword(n, r, { autoRefreshThreshold: 1800 }), a;
+}), m = t.object({
 	name: t.string(),
 	enabled: t.boolean(),
 	handler: t.string(),
@@ -58,34 +52,46 @@ 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 h(e) {
+	let t = await p(), n = await t.collection("ai_providers").getFirstListItem(t.filter("name={:name}", { name: e }));
+	return m.parse(n);
 }
-var _ = e(g, {
+var g = a(h, {
 	ttl: 6e4,
 	resolver: (e) => e
-}), v = t.object({
+}), _ = 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(),
+	outputSchema: s.nullish(),
+	overrideOptions: c.nullish(),
 	capabilities: t.string().array(),
 	expand: t.object({
-		providers: h.array().min(1),
-		capabilities: f.array().optional()
+		providers: m.array().min(1),
+		capabilities: l.array().optional()
 	})
 });
-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 v(e) {
+	let t = await p(), n = await t.collection("ai_souls").getFirstListItem(t.filter("name={:name}", { name: e }), { expand: "providers,capabilities" });
+	return _.parse(n);
 }
-var b = e(y, {
+var y = a(v, {
 	ttl: 6e4,
 	resolver: (e) => e
+}), b = 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 x(e) {
+	let t = await p(), n = t.filter(Object.keys(e).filter((t) => e[t]).map((e) => `${e} = {:${e}}`).join(" && "), e);
+	return await t.collection("tokens").getFirstListItem(n);
+}
 //#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 { g as cachedFetchProvider, y as cachedFetchSoul, l as capabilitySchema, h as fetchProvider, v as fetchSoul, x as findToken, p as getPb, o as jsonSchema, s as outputSchema, c as overrideOptionsSchema, m as providerSchema, f as setPocketBaseEnv, _ as soulSchema, b as tokenRecordSchema };

package/dist/souls.d.ts

@@ -51,9 +51,7 @@ export declare const soulSchema: z.ZodObject<{
                 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">;
@@ -90,9 +88,7 @@ export declare function fetchSoul(name: string): Promise<{
             category: "mode" | "tool";
             phase: "plan" | "respond";
             description: string;
-            triggerHint: string;
             alwaysActive: boolean;
-            threshold: number;
             presentationPrompt?: string | null | undefined;
             inputSchema?: {
                 [x: string]: unknown;
@@ -147,9 +143,7 @@ export declare const cachedFetchSoul: import("@gera2ld/async-memo").CachedFuncti
             category: "mode" | "tool";
             phase: "plan" | "respond";
             description: string;
-            triggerHint: string;
             alwaysActive: boolean;
-            threshold: number;
             presentationPrompt?: string | null | undefined;
             inputSchema?: {
                 [x: string]: unknown;

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.22",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "import": "./dist/index.js",