@gera2ld/pb-datacenter 0.0.21 → 0.1.0

package/dist/capabilities.d.ts

@@ -0,0 +1,21 @@
+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;
+    alwaysActive: z.ZodBoolean;
+    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>;

package/dist/index.d.ts

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

package/dist/index.js

@@ -18,22 +18,30 @@ var o = t.looseObject({
 })]), c = t.object({
 	maxOutputTokens: t.coerce.number(),
 	temperature: t.coerce.number()
-}).partial(), l = [
+}).partial(), l = t.object({
+	name: t.string(),
+	category: t.enum(["mode", "tool"]).catch("tool"),
+	phase: t.enum(["plan", "respond"]).catch("plan"),
+	description: t.string(),
+	alwaysActive: t.boolean(),
+	presentationPrompt: t.string().nullish(),
+	inputSchema: o.nullish()
+}), u = [
 	"POCKETBASE_URL",
 	"POCKETBASE_ADMIN_USER",
 	"POCKETBASE_ADMIN_PASS"
-], u = r(process.env, l);
-function d(e) {
-	l.forEach((t) => {
-		e[t] != null && (u[t] = e[t]);
+], d = r(process.env, u);
+function f(e) {
+	u.forEach((t) => {
+		e[t] != null && (d[t] = e[t]);
 	});
 }
-var f = n(async function() {
-	let e = l.filter((e) => !u[e]);
+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 } = u, a = new i(t).autoCancellation(!1);
+	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;
-}), p = t.object({
+}), m = t.object({
 	name: t.string(),
 	enabled: t.boolean(),
 	handler: t.string(),
@@ -44,14 +52,35 @@ var f = n(async function() {
 	}).partial().nullish(),
 	options: t.record(t.string(), t.any()).nullish()
 });
-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);
+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 g = a(h, {
+	ttl: 6e4,
+	resolver: (e) => e
+}), _ = t.object({
+	id: t.string(),
+	name: t.string(),
+	basePrompt: t.string(),
+	presentationPrompt: t.string(),
+	providers: t.string().array().min(1),
+	outputSchema: s.nullish(),
+	overrideOptions: c.nullish(),
+	capabilities: t.string().array(),
+	expand: t.object({
+		providers: m.array().min(1),
+		capabilities: l.array().optional()
+	})
+});
+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 h = a(m, {
+var y = a(v, {
 	ttl: 6e4,
 	resolver: (e) => e
-}), g = e.object({
+}), b = e.object({
 	id: e.string(),
 	name: e.string(),
 	token: e.string(),
@@ -60,9 +89,9 @@ var h = a(m, {
 	created: e.string(),
 	updated: e.string()
 });
-async function _(e) {
-	let t = await f(), n = t.filter(Object.keys(e).filter((t) => e[t]).map((e) => `${e} = {:${e}}`).join(" && "), e);
+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 { 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 };
+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/providers.d.ts

@@ -26,7 +26,7 @@ export declare function fetchProvider(name: string): Promise<{
     } | null | undefined;
     options?: Record<string, any> | null | undefined;
 }>;
-export declare const cachedFetchProvider: import("@gera2ld/async-memo").CachedFunction<[name: string], {
+export declare const cachedFetchProvider: import("@gera2ld/async-memo").AsyncMemoContext<[name: string], {
     name: string;
     enabled: boolean;
     handler: string;

package/dist/souls.d.ts

@@ -0,0 +1,174 @@
+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;
+            alwaysActive: z.ZodBoolean;
+            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;
+            alwaysActive: boolean;
+            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").AsyncMemoContext<[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;
+            alwaysActive: boolean;
+            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

@@ -1,6 +1,6 @@
 {
   "name": "@gera2ld/pb-datacenter",
-  "version": "0.0.21",
+  "version": "0.1.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -20,10 +20,10 @@
     "@gera2ld/common-node": "^0.0.20"
   },
   "dependencies": {
-    "@gera2ld/async-memo": "^1.0.0",
-    "es-toolkit": "^1.45.1",
-    "pocketbase": "^0.26.8",
-    "zod": "^4.3.6"
+    "@gera2ld/async-memo": "^2.0.1",
+    "es-toolkit": "^1.49.0",
+    "pocketbase": "^0.27.0",
+    "zod": "^4.4.3"
   },
   "scripts": {
     "clean": "del-cli dist tsconfig.tsbuildinfo",