godprotocol 2.2.85 → 2.2.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "2.2.85",
+  "version": "2.2.86",
   "description": "A distributed computing environment for Web 4.0 — integrating AI, decentralisation, and virtual computation.",
   "main": "Index.js",
   "type": "module",

package/server/Routable/Create platform,

@@ -0,0 +1,5 @@
+Create platform,
+
+Register it to arena, adding its permissions.
+
+Use arena to signup your users.

package/server/Routable/Header.js

@@ -221,6 +221,9 @@ class Headers extends Services {
   handle_security = async (name, request) => {
     let route = await this.get_route(name);
 
+    if (!route) {
+      route = await this.get_route("*");
+    }
     if (!route?.config?.security?.length) return true;
 
     if (!this.check_security(route.config.security, request)) {

package/server/Routable/Storyline,.md

@@ -0,0 +1,20 @@
+Storyline,
+
+Assistant recieves a prompt.
+
+It thinks it through, into type, and if type is activity, it determines the activity tool.
+(This is a thought action, meaning it does not carry personality, it just takes memory and reasoning.)
+
+Next stage is that it tries to resolve the selection arguments.
+If tool or what have you, it uses memory, context argument and prompt to determine what information it can already put together to resolve the selected.
+(This is the second thought action it carries out. They are thought actions because they are simply the agent reasoning within itself. And the world watching for an output / action it would come with.)
+
+Once, all that is done, it sends its action to the tool service aka it simply calls the tool service. It meta information is included in the call. Such as the conversation_id
+
+// At the tool service end.
+
+When it handles the endpoint, What ever solution it gets, it returns an agent, which is just a profile. i.e the handling profile.
+
+When godprotocol sees a response includes an agent property,
+it calls the agency service response endpoint, adding the handler payload to the call, and the conversation_id provided.
+Of course the platform i.e tool service must have third party authenticated the agent from them to the agent's own agency profile.

package/server/Routable/The Story Board.md

@@ -0,0 +1,34 @@
+The Story Board.
+
+First entry is the new_message endpoint.
+
+The user sends a message to that endpoint,
+if a conversation is provided, we retrieve the conversation.
+
+If not a conversation is provided, we infer one.
+A conversation is simply an activity (aka tool) discussion.
+
+There are three conversation kinds - activity (tools), feedback (preferences statements and corrections), pleasantry (small talks).
+
+If activity, we include tool_id, and args.
+If feedback, we include tool_id.
+if pleasantry, not much,
+
+Conversations also includes a spawn object, which is a {conversation, message} \_ids.
+
+=================
+
+Next is new_message,
+So a message is sent.
+
+We determine what categories the message is about.
+Categories are - argument_resolution, new_conversation, abandon_conversation, or feedback.
+
+First variable = m (the initiator)
+Second variable = c (the resolver)
+Third variable = x (the problem aka action)
+
+Fourth variable = y (the solution)
+
+mx + c = y
+(Need item)(buy item) + (seller) = (item)

package/server/Routable/The flow is simple. It is thus.

@@ -0,0 +1,15 @@
+The flow is simple. It is thus.
+
+When you create a platform, you register it to a central platform.
+In this case, arena is the vote.
+
+So every single platform is registered as a third party to arena.
+The endpoint is able to recursively register the requesting platform under its requested permissions also.
+
+Those platforms state their dependencies aka permissions.
+
+Which arena would also have in its third parties.
+
+When those platforms want to register new profiles,
+they use the third_party endpoints of (signin, and signup)
+

package/server/Routable/When you send a message first ->

@@ -0,0 +1,8 @@
+When you send a message first ->
+
+Question, does the system start with a message sent in?
+Or the architectural arrangement of profiles.
+
+
+And if message first, then how does it flow conversationally.
+

package/server/Routable/const Modelconfig = {

@@ -0,0 +1,5 @@
+const Modelconfig = {
+  drivers: [],
+  animations: [],
+  geometry: [],
+}