@knowlearning/agents 0.9.112 → 0.9.114

package/deno.js

@@ -5,75 +5,88 @@ const AGENT_TOKEN = Deno.env.get('AGENT_TOKEN')
 
 const denoProcess = self
 
-function Connection() {
+function Connection(domain) {
+  const connection = crypto.randomUUID()
   const thisConnection = this
 
-  thisConnection.send = message => denoProcess.postMessage(message)
+  thisConnection.send = message => denoProcess.postMessage({ ...message, domain, connection })
 
-  const delay = new Promise(r => setTimeout(r))
-  delay.then(() => thisConnection.onopen())
-  denoProcess.onmessage = ({ data }) => thisConnection.onmessage(data)
+  denoProcess.addEventListener('message', ({ data }) => {
+    if (data.connection === connection) thisConnection.onmessage(data)
+  })
+
+  //  TODO: consider what onclose and onerror mean
+  setTimeout(() => thisConnection.onopen())
 
-  //  TODO: consider what onclose and onerror mean in this case
   return thisConnection
 }
 
 const children = {}
 const listeners = {}
 
-const agent = new Agent({
-  Connection,
-  token: () => AGENT_TOKEN,
-  uuid: () => crypto.randomUUID(),
-  async log() {
-    await new Promise(r => r()) // so we can access our own agent instance
+const agents = {}
 
-    const { session } = await agent.environment()
-    let value
+function getAgent(domain, forceNew) {
+  if (agents[domain] && !forceNew) return agents[domain]
 
-    try {
-      value = structuredClone([...arguments])
-    }
-    catch (error) {
-      value = `ERROR: error occurred logging arguments ${error} ${arguments}`
-    }
+  agents[domain] = new Agent({
+    Connection: Connection(domain), // TODO: probably don't want to need to pass domain here, as first message from generic agent should pass it
+    domain,
+    token: () => AGENT_TOKEN,
+    uuid: () => crypto.randomUUID(),
+    async log() {
+      await new Promise(r => r()) // so we can access our own agent instance
+
+      const { session } = await agent.environment()
+      let value
+
+      try {
+        value = structuredClone([...arguments])
+      }
+      catch (error) {
+        value = `ERROR: error occurred logging arguments ${error} ${arguments}`
+      }
 
-    agent.interact('sessions', [{ op: 'add', path: ['active', session, 'log'], value }], false, false)
-  },
-  fetch,
-  applyPatch: fastJSONPatch.applyPatch,
-  reboot: () => Deno.exit(1),
-  handleDomainMessage: ({ type, session, data }, trigger) => {
-    //  this functionality is only implemented for the deno
-    //  agent for now, but this central management of children
-    //  concept probably has a place in the generic agent
-    if (type === 'open') {
-      const child = {
-        environment: data,
-        on: (eventType, reaction) => {
-          if (!listeners[session]) throw new Error('Error attaching listener, child is closed')
-          if (!listeners[session][eventType]) throw new Error('Only "mutate" and "close" events can be listened to with Agent.on')
-          listeners[session][eventType].push(reaction)
+      agent.interact('sessions', [{ op: 'add', path: ['active', session, 'log'], value }], false, false)
+    },
+    fetch,
+    applyPatch: fastJSONPatch.applyPatch,
+    reboot: () => Deno.exit(1),
+    handleDomainMessage: ({ type, session, data }, trigger) => {
+      //  this functionality is only implemented for the deno
+      //  agent for now, but this central management of children
+      //  concept probably has a place in the generic agent
+      if (type === 'open') {
+        const child = {
+          environment: data,
+          on: (eventType, reaction) => {
+            if (!listeners[session]) throw new Error('Error attaching listener, child is closed')
+            if (!listeners[session][eventType]) throw new Error('Only "mutate" and "close" events can be listened to with Agent.on')
+            listeners[session][eventType].push(reaction)
+          }
         }
+        listeners[session] = { mutate: [], close: [] }
+        children[session] = child
+        trigger('child', child)
+      }
+      else if (type === 'mutate') {
+        const filteredData = { ...data, patch: activePatch(data.patch) }
+        listeners[session].mutate.forEach(f => f(filteredData))
+      }
+      else if (type === 'close') {
+        listeners[session].close.forEach(f => f(data))
+        delete listeners[session]
+        delete children[session]
       }
-      listeners[session] = { mutate: [], close: [] }
-      children[session] = child
-      trigger('child', child)
-    }
-    else if (type === 'mutate') {
-      const filteredData = { ...data, patch: activePatch(data.patch) }
-      listeners[session].mutate.forEach(f => f(filteredData))
-    }
-    else if (type === 'close') {
-      listeners[session].close.forEach(f => f(data))
-      delete listeners[session]
-      delete children[session]
     }
-  }
-})
+  })
+
+  return agents[domain]
+}
 
 function activePatch(patch) {
   return structuredClone(patch).filter(({ path }) => 'active' === path.shift())
 }
 
-export default agent
+export default getAgent(null)
+export { getAgent }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowlearning/agents",
-  "version": "0.9.112",
+  "version": "0.9.114",
   "description": "API for embedding applications in KnowLearning systems.",
   "main": "node.js",
   "browser": "browser.js",