@base44-preview/cli 0.0.25-pr.151.082c391 → 0.0.25-pr.151.1ef8126

package/dist/index.js

@@ -5747,77 +5747,6 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
-const $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
-	$ZodType.init(inst, def);
-	const items = def.items;
-	inst._zod.parse = (payload, ctx) => {
-		const input = payload.value;
-		if (!Array.isArray(input)) {
-			payload.issues.push({
-				input,
-				inst,
-				expected: "tuple",
-				code: "invalid_type"
-			});
-			return payload;
-		}
-		payload.value = [];
-		const proms = [];
-		const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-		const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
-		if (!def.rest) {
-			const tooBig = input.length > items.length;
-			const tooSmall = input.length < optStart - 1;
-			if (tooBig || tooSmall) {
-				payload.issues.push({
-					...tooBig ? {
-						code: "too_big",
-						maximum: items.length,
-						inclusive: true
-					} : {
-						code: "too_small",
-						minimum: items.length
-					},
-					input,
-					inst,
-					origin: "array"
-				});
-				return payload;
-			}
-		}
-		let i$1 = -1;
-		for (const item of items) {
-			i$1++;
-			if (i$1 >= input.length) {
-				if (i$1 >= optStart) continue;
-			}
-			const result = item._zod.run({
-				value: input[i$1],
-				issues: []
-			}, ctx);
-			if (result instanceof Promise) proms.push(result.then((result$1) => handleTupleResult(result$1, payload, i$1)));
-			else handleTupleResult(result, payload, i$1);
-		}
-		if (def.rest) {
-			const rest = input.slice(items.length);
-			for (const el of rest) {
-				i$1++;
-				const result = def.rest._zod.run({
-					value: el,
-					issues: []
-				}, ctx);
-				if (result instanceof Promise) proms.push(result.then((result$1) => handleTupleResult(result$1, payload, i$1)));
-				else handleTupleResult(result, payload, i$1);
-			}
-		}
-		if (proms.length) return Promise.all(proms).then(() => payload);
-		return payload;
-	};
-});
-function handleTupleResult(result, final, index) {
-	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
-	final.value[index] = result.value;
-}
 const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -6140,17 +6069,6 @@ function handleReadonlyResult(payload) {
 	payload.value = Object.freeze(payload.value);
 	return payload;
 }
-const $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
-	$ZodType.init(inst, def);
-	defineLazy(inst._zod, "innerType", () => def.getter());
-	defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
-	defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
-	defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
-	defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
-	inst._zod.parse = (payload, ctx) => {
-		return inst._zod.innerType._zod.run(payload, ctx);
-	};
-});
 const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
 	$ZodCheck.init(inst, def);
 	$ZodType.init(inst, def);
@@ -7211,44 +7129,6 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a$1) ? a$1.allOf : [a$1], ...isSimpleIntersection(b$2) ? b$2.allOf : [b$2]];
 };
-const tupleProcessor = (schema, ctx, _json, params) => {
-	const json = _json;
-	const def = schema._zod.def;
-	json.type = "array";
-	const prefixPath$1 = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
-	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-	const prefixItems = def.items.map((x$2, i$1) => process$3(x$2, ctx, {
-		...params,
-		path: [
-			...params.path,
-			prefixPath$1,
-			i$1
-		]
-	}));
-	const rest = def.rest ? process$3(def.rest, ctx, {
-		...params,
-		path: [
-			...params.path,
-			restPath,
-			...ctx.target === "openapi-3.0" ? [def.items.length] : []
-		]
-	}) : null;
-	if (ctx.target === "draft-2020-12") {
-		json.prefixItems = prefixItems;
-		if (rest) json.items = rest;
-	} else if (ctx.target === "openapi-3.0") {
-		json.items = { anyOf: prefixItems };
-		if (rest) json.items.anyOf.push(rest);
-		json.minItems = prefixItems.length;
-		if (!rest) json.maxItems = prefixItems.length;
-	} else {
-		json.items = prefixItems;
-		if (rest) json.additionalItems = rest;
-	}
-	const { minimum, maximum } = schema._zod.bag;
-	if (typeof minimum === "number") json.minItems = minimum;
-	if (typeof maximum === "number") json.maxItems = maximum;
-};
 const recordProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -7344,12 +7224,6 @@ const optionalProcessor = (schema, ctx, _json, params) => {
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
-const lazyProcessor = (schema, ctx, _json, params) => {
-	const innerType = schema._zod.innerType;
-	process$3(innerType, ctx, params);
-	const seen = ctx.seen.get(schema);
-	seen.ref = innerType;
-};
 
 //#endregion
 //#region node_modules/zod/v4/classic/iso.js
@@ -7806,25 +7680,6 @@ function intersection(left, right) {
 		right
 	});
 }
-const ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
-	$ZodTuple.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
-	inst.rest = (rest) => inst.clone({
-		...inst._zod.def,
-		rest
-	});
-});
-function tuple(items, _paramsOrRest, _params) {
-	const hasRest = _paramsOrRest instanceof $ZodType;
-	const params = hasRest ? _params : _paramsOrRest;
-	return new ZodTuple({
-		type: "tuple",
-		items,
-		rest: hasRest ? _paramsOrRest : null,
-		...normalizeParams(params)
-	});
-}
 const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
 	$ZodRecord.init(inst, def);
 	ZodType.init(inst, def);
@@ -8046,18 +7901,6 @@ function readonly(innerType) {
 		innerType
 	});
 }
-const ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
-	$ZodLazy.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => lazyProcessor(inst, ctx, json, params);
-	inst.unwrap = () => inst._zod.def.getter();
-});
-function lazy(getter) {
-	return new ZodLazy({
-		type: "lazy",
-		getter
-	});
-}
 const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
 	$ZodCustom.init(inst, def);
 	ZodType.init(inst, def);
@@ -16759,65 +16602,61 @@ const { convertPathToPattern } = import_out.default;
 
 //#endregion
 //#region src/core/resources/entity/schema.ts
-/**
-* Operator-based field condition (e.g., { $in: "{{user.id}}" })
-*/
-const FieldConditionOperatorSchema = object({
+const FieldConditionSchema = union([string(), object({
 	$in: unknown().optional(),
 	$nin: unknown().optional(),
 	$ne: unknown().optional(),
 	$all: unknown().optional()
-});
-/**
-* Field condition - either a string value/template or an operator object
-*/
-const FieldConditionSchema = union([string(), FieldConditionOperatorSchema]);
-/**
-* User condition for direct property checks (equality only)
-* Supports: role, email, id, and data.* pattern properties
-*/
-const UserConditionSchema = object({
+})]);
+const userConditionAllowedKeys = new Set([
+	"role",
+	"email",
+	"id"
+]);
+const UserConditionSchema = looseObject({
 	role: string().optional(),
 	email: string().optional(),
 	id: string().optional()
-}).catchall(unknown()).refine((obj) => {
-	const allowedKeys = new Set([
-		"role",
-		"email",
-		"id"
-	]);
-	const dataPattern = /^data\.[a-zA-Z0-9_]+$/;
-	for (const key of Object.keys(obj)) if (!allowedKeys.has(key) && !dataPattern.test(key)) return false;
-	return true;
-}, { message: "User condition keys must be role, email, id, or match data.* pattern" });
-const RLSConditionSchema = lazy(() => object({
+}).refine((val) => Object.keys(val).every((key) => userConditionAllowedKeys.has(key) || key.startsWith("data.")), "Keys must be role, email, id, or match data.* pattern");
+const rlsConditionAllowedKeys = new Set([
+	"user_condition",
+	"created_by",
+	"created_by_id",
+	"$or",
+	"$and",
+	"$nor"
+]);
+const RLSConditionSchema = looseObject({
 	user_condition: UserConditionSchema.optional(),
-	$or: array(RLSConditionSchema).optional(),
-	$and: array(RLSConditionSchema).optional(),
-	$nor: array(RLSConditionSchema).optional(),
 	created_by: FieldConditionSchema.optional(),
-	created_by_id: FieldConditionSchema.optional()
-}).catchall(FieldConditionSchema).refine((obj) => {
-	const allowedKeys = new Set([
-		"user_condition",
-		"$or",
-		"$and",
-		"$nor",
-		"created_by",
-		"created_by_id"
-	]);
-	const dataPattern = /^data\.[a-zA-Z0-9_.]+$/;
-	for (const key of Object.keys(obj)) if (!allowedKeys.has(key) && !dataPattern.test(key)) return false;
-	return true;
-}, { message: "RLS condition keys must be known fields or match data.* pattern" }));
-/**
-* RLS Rule - either a boolean or a condition object
-*/
-const RLSRuleSchema = union([boolean(), RLSConditionSchema]);
-/**
-* Entity-level RLS - controls which records users can access
-* Only allows: create, read, update, delete, write
-*/
+	created_by_id: FieldConditionSchema.optional(),
+	get $or() {
+		return array(RefineRLSConditionSchema).optional();
+	},
+	get $and() {
+		return array(RefineRLSConditionSchema).optional();
+	},
+	get $nor() {
+		return array(RefineRLSConditionSchema).optional();
+	}
+});
+const fieldConditionOperators = new Set([
+	"$in",
+	"$nin",
+	"$ne",
+	"$all"
+]);
+const isValidFieldCondition = (value) => {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
+	if (typeof value === "object") return Object.keys(value).every((k$2) => fieldConditionOperators.has(k$2));
+	return false;
+};
+const RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => {
+	if (rlsConditionAllowedKeys.has(key)) return true;
+	if (!key.startsWith("data.")) return false;
+	return isValidFieldCondition(value);
+}), "Keys must be known RLS keys or match data.* pattern with valid value");
+const RLSRuleSchema = union([boolean(), RefineRLSConditionSchema]);
 const EntityRLSSchema = strictObject({
 	create: RLSRuleSchema.optional(),
 	read: RLSRuleSchema.optional(),
@@ -16825,10 +16664,6 @@ const EntityRLSSchema = strictObject({
 	delete: RLSRuleSchema.optional(),
 	write: RLSRuleSchema.optional()
 });
-/**
-* Field-level RLS - controls which fields users can access within records
-* Only allows: read, write, create, update, delete
-*/
 const FieldRLSSchema = strictObject({
 	read: RLSRuleSchema.optional(),
 	write: RLSRuleSchema.optional(),
@@ -16836,9 +16671,6 @@ const FieldRLSSchema = strictObject({
 	update: RLSRuleSchema.optional(),
 	delete: RLSRuleSchema.optional()
 });
-/**
-* Property types supported by Base44 entities
-*/
 const PropertyTypeSchema = _enum([
 	"string",
 	"number",
@@ -16848,9 +16680,6 @@ const PropertyTypeSchema = _enum([
 	"object",
 	"binary"
 ]);
-/**
-* String format validation options
-*/
 const StringFormatSchema = _enum([
 	"date",
 	"date-time",
@@ -16864,11 +16693,7 @@ const StringFormatSchema = _enum([
 	"file",
 	"regex"
 ]);
-/**
-* Entity reference pattern: /entities/{EntityName}/id
-*/
-const EntityRefSchema = string().regex(/^\/entities\/[a-zA-Z0-9]+\/id$/, "Reference must match pattern /entities/{EntityName}/id");
-const PropertyDefinitionSchema = lazy(() => object({
+const PropertyDefinitionSchema = object({
 	type: PropertyTypeSchema,
 	title: string().optional(),
 	description: string().optional(),
@@ -16881,23 +16706,19 @@ const PropertyDefinitionSchema = lazy(() => object({
 	enum: array(string()).optional(),
 	enumNames: array(string()).optional(),
 	default: unknown().optional(),
-	$ref: EntityRefSchema.optional(),
-	items: PropertyDefinitionSchema.optional(),
-	properties: record(string(), PropertyDefinitionSchema).optional(),
+	$ref: string().optional(),
+	rls: FieldRLSSchema.optional(),
 	required: array(string()).optional(),
-	rls: FieldRLSSchema.optional()
-}));
-/**
-* Entity name pattern: alphanumeric only, no spaces or special characters
-*/
-const EntityNameSchema = string().regex(/^[a-zA-Z0-9]+$/, "Entity name must be alphanumeric only");
-/**
-* Full Entity Schema for Base44 entity configuration
-* Defines data structures with validation, security rules, and relationships
-*/
+	get items() {
+		return PropertyDefinitionSchema.optional();
+	},
+	get properties() {
+		return record(string(), PropertyDefinitionSchema).optional();
+	}
+});
 const EntitySchema = object({
 	type: literal("object"),
-	name: EntityNameSchema,
+	name: string().regex(/^[a-zA-Z0-9]+$/, "Entity name must be alphanumeric only"),
 	title: string().optional(),
 	description: string().optional(),
 	properties: record(string(), PropertyDefinitionSchema),
@@ -16962,14 +16783,23 @@ const entityResource = {
 
 //#endregion
 //#region src/core/resources/function/schema.ts
+const FunctionNameSchema = string().trim().min(1, "Function name cannot be empty").regex(/^[^.]+$/, "Function name cannot contain dots");
+const FunctionFileSchema = object({
+	path: string().min(1),
+	content: string()
+});
 const FunctionConfigSchema = object({
-	name: string().min(1, "Function name cannot be empty").refine((name$1) => !name$1.includes("."), "Function name cannot contain dots"),
-	entry: string().min(1, "Entry point cannot be empty"),
-	triggers: tuple([]).optional()
+	name: FunctionNameSchema,
+	entry: string().min(1, "Entry point cannot be empty")
 });
 const FunctionSchema = FunctionConfigSchema.extend({
 	entryPath: string().min(1, "Entry path cannot be empty"),
-	files: array(string()).min(1, "Files array cannot be empty")
+	files: array(string()).min(1, "Function must have at least one file")
+});
+const FunctionDeploySchema = object({
+	name: FunctionNameSchema,
+	entry: string().min(1),
+	files: array(FunctionFileSchema).min(1, "Function must have at least one file")
 });
 const DeployFunctionsResponseSchema = object({
 	deployed: array(string()),
@@ -17073,7 +16903,30 @@ const functionResource = {
 
 //#endregion
 //#region src/core/resources/agent/schema.ts
-const AgentConfigSchema = looseObject({ name: string().regex(/^[a-z0-9_]+$/, "Agent name must be lowercase alphanumeric with underscores").min(1).max(100) });
+const EntityOperationSchema = _enum([
+	"create",
+	"update",
+	"delete",
+	"read"
+]);
+const EntityToolConfigSchema = object({
+	entity_name: string().min(1),
+	allowed_operations: array(EntityOperationSchema)
+});
+const BackendFunctionToolConfigSchema = object({
+	function_name: string().min(1),
+	description: string().default("agent backend function")
+});
+const ToolConfigSchema = union([EntityToolConfigSchema, BackendFunctionToolConfigSchema]);
+const ModelSchema = string().regex(/^(default|(anthropic|gemini|openai|vertex_ai)\/.+)$/, "Model must be \"default\" or start with: anthropic/, gemini/, openai/, vertex_ai/");
+const AgentConfigSchema = looseObject({
+	name: string().regex(/^[a-z0-9_]+$/, "Agent name must be lowercase alphanumeric with underscores").min(1).max(100),
+	description: string().trim().min(1, "Description is required"),
+	instructions: string().trim().min(1, "Instructions are required"),
+	tool_configs: array(ToolConfigSchema).optional().default([]),
+	whatsapp_greeting: string().nullable().optional().default(null),
+	model: ModelSchema.optional().default("default")
+});
 const SyncAgentsResponseSchema = object({
 	created: array(string()),
 	updated: array(string()),

package/dist/templates/backend-and-client/base44/agents/task_manager.jsonc

@@ -0,0 +1,11 @@
+{
+  "name": "task_manager",
+  "description": "An AI agent that helps you manage and change your tasks",
+  "instructions": "You are a helpful task management assistant. You can help users create, update, mark as completed, and delete tasks using the entity tool. When a user asks to change a task, help them modify it by updating the appropriate fields. Always be conversational and helpful.",
+  "tool_configs": [
+    {
+      "entity_name": "Task",
+      "allowed_operations": ["read", "create", "update", "delete"]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.25-pr.151.082c391",
+  "version": "0.0.25-pr.151.1ef8126",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "bin": {
@@ -70,6 +70,5 @@
   },
   "optionalDependencies": {
     "@rollup/rollup-linux-x64-gnu": "^4.56.0"
-  },
-  "packageManager": "yarn@4.12.0+sha256.1fe4e1193cbcd13a48d8f436bb17d3c672b049a5e32a758aab9866a073db1702"
+  }
 }