akanjs 3.0.0-alpha.32 → 3.0.0-alpha.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.32",
+  "version": "3.0.0-alpha.34",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/store/agentic/StToolBuilder.ts

@@ -82,9 +82,9 @@ export class StToolBuilder<Args extends unknown[] = []> {
     type: T,
     option: StToolArgOption<ArgValue<T>> = {},
   ): StToolBuilder<[...Args, ArgValue<T> | null]> {
-    
-    StToolBuilder.schemaOf(type);
-    return new StToolBuilder(this.#name, this.#meta, [
+
+    const published = this.#name && StToolBuilder.#describable(this.#name, name, type) ? this.#name : null;
+    return new StToolBuilder(published, this.#meta, [
       ...this.#args,
       { name, type, optional: !!option.optional, ...(option.oneOf ? { oneOf: option.oneOf } : {}) },
     ]);
@@ -150,6 +150,20 @@ export class StToolBuilder<Args extends unknown[] = []> {
     return arg.oneOf ? { ...schema, enum: [...arg.oneOf] } : schema;
   }
 
+  static #describable(toolName: string, argName: string, type: ParamFieldType): boolean {
+    try {
+      StToolBuilder.schemaOf(type);
+      return true;
+    } catch (error) {
+      console.error(
+        `st.tool("${toolName}") is not published: its "${argName}" argument is ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+      return false;
+    }
+  }
+
   /** Scalars and enums only — the value arrives as JSON from a model, so a class instance has no way in. */
   static schemaOf(type: ParamFieldType): JsonSchema {
     if (isEnum(type as Cls)) {
@@ -159,7 +173,7 @@ export class StToolBuilder<Args extends unknown[] = []> {
     }
     const scalar = type as typeof PrimitiveScalar;
     if (!PrimitiveRegistry.has(scalar as unknown as Cls))
-      throw new Error("st.tool takes scalar and enum arguments only.");
+      throw new Error(`${StToolBuilder.#typeName(type)}, and st.tool takes scalar and enum arguments only.`);
     switch (PrimitiveRegistry.getName(scalar)) {
       case "ID":
       case "String":
@@ -173,10 +187,15 @@ export class StToolBuilder<Args extends unknown[] = []> {
       case "Date":
         return { type: "string", format: "date-time" };
       default:
-        throw new Error(`st.tool cannot describe the scalar ${PrimitiveRegistry.getName(scalar)}.`);
+        throw new Error(`the scalar ${PrimitiveRegistry.getName(scalar)}, which st.tool cannot describe.`);
     }
   }
 
+  static #typeName(type: ParamFieldType): string {
+    const named = type as { name?: string } | null | undefined;
+    return named?.name ? `the type ${named.name}` : `${String(type)}`;
+  }
+
   static positionalOf(toolName: string, args: StToolArg[], named: Record<string, unknown>): unknown[] {
     return args.map((arg) => {
       const value = named[arg.name];

package/store/agentic/useStState.ts

@@ -20,16 +20,30 @@ export const useStState = <T>(
   initial: T | (() => T),
   meta: StStateMeta<T> = {},
 ): [T, Dispatch<SetStateAction<T>>] => {
-  const set = meta.set;
+
+  const set = name && meta.set ? writable(name, meta.set) : null;
   return useAgentState<T>(name, initial, {
     description: meta.desc,
     report: meta.report,
     serialize: meta.serialize ?? ((value) => readableValue(name ?? "", value, meta.mask)),
     ...(set
       ? {
-          set: StToolBuilder.schemaOf(set),
-          parse: (value) => StToolBuilder.checkedValue(`set${capitalize(name ?? "")}`, "value", set, value) as T,
+          set: set.schema,
+          parse: (value) => StToolBuilder.checkedValue(`set${capitalize(name ?? "")}`, "value", set.type, value) as T,
         }
       : {}),
   });
 };
+
+const writable = (name: string, type: ParamFieldType) => {
+  try {
+    return { schema: StToolBuilder.schemaOf(type), type };
+  } catch (error) {
+    console.error(
+      `st.useState("${name}") stays read-only: its "set" type is ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+    return null;
+  }
+};