@gera2ld/pb-datacenter 0.0.3

package/dist/capabilities.d.ts

@@ -0,0 +1,55 @@
+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/common.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export declare const jsonSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const outputSchema: 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>]>;
+export type OutputSchema = z.infer<typeof outputSchema>;
+export declare const overrideOptionsSchema: z.ZodObject<{
+    maxOutputTokens: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    temperature: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type OverrideOptionsSchema = z.infer<typeof overrideOptionsSchema>;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,91 @@
+import { asyncMemo as e } from "@gera2ld/async-memo";
+import { z as t } from "zod";
+import { once as n, pick as r } from "es-toolkit";
+import i from "pocketbase";
+//#region src/common.ts
+var a = t.looseObject({
+	type: t.literal("object"),
+	properties: t.record(t.string(), t.unknown()),
+	required: t.string().array().optional()
+}), o = t.union([t.object({
+	type: t.enum(["object", "array"]),
+	description: t.string().optional(),
+	schema: a
+}), t.object({
+	type: t.literal("choice"),
+	description: t.string().optional(),
+	options: t.string().array()
+})]), s = t.object({
+	maxOutputTokens: t.coerce.number(),
+	temperature: t.coerce.number()
+}).partial(), c = [
+	"POCKETBASE_BASE_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_BASE_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({
+	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({
+	name: t.string(),
+	enabled: t.boolean(),
+	handler: t.string(),
+	model: t.string(),
+	metadata: t.object({
+		price: t.number(),
+		image: t.object({ single: t.boolean() }).partial()
+	}).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);
+}
+var _ = e(g, {
+	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()
+	})
+});
+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);
+}
+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 };

package/dist/pocketbase.d.ts

@@ -0,0 +1,3 @@
+import PocketBase from "pocketbase";
+export declare function setPocketBaseEnv(value: Record<string, string>): void;
+export declare const getPb: () => Promise<PocketBase>;

package/dist/providers.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const providerSchema: 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>;
+export type ProviderSchema = z.infer<typeof providerSchema>;
+export declare function fetchProvider(name: string): Promise<{
+    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;
+}>;
+export declare const cachedFetchProvider: import("@gera2ld/async-memo").CachedFunction<[name: string], {
+    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;
+}, Map<string, import("@gera2ld/async-memo").CacheData<unknown>>>;

package/dist/souls.d.ts

@@ -0,0 +1,180 @@
+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>>>;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@gera2ld/pb-datacenter",
+  "version": "0.0.3",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@gera2ld/common-node": "^0.0.3"
+  },
+  "dependencies": {
+    "@gera2ld/async-memo": "^1.0.0",
+    "es-toolkit": "^1.45.1",
+    "pocketbase": "^0.26.8",
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "clean": "del-cli dist tsconfig.tsbuildinfo",
+    "build:types": "tsc",
+    "build:js": "vite build",
+    "build": "pnpm clean && pnpm /^build:/"
+  }
+}