@forbocai/core 0.5.4 → 0.5.7

package/dist/index.mjs

@@ -1,8 +1,6 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export
+} from "./chunk-7P6ASYW6.mjs";
 
 // src/agent.ts
 var createInitialState = (partial) => {
@@ -14,17 +12,6 @@ var updateAgentState = (currentState, updates) => {
     ...updates
   };
 };
-var processAgentInput = (currentState, input, context = {}) => {
-  const stateKeys = Object.keys(currentState);
-  const stateSummary = stateKeys.length > 0 ? stateKeys.map((k) => `${k}=${JSON.stringify(currentState[k])}`).join(", ") : "empty";
-  return {
-    dialogue: `Processing: "${input}" (State: ${stateSummary})`,
-    action: {
-      type: "respond",
-      reason: "Default processing"
-    }
-  };
-};
 var exportToSoul = (agentId, name, persona, state, memories) => {
   return {
     id: agentId,
@@ -37,10 +24,10 @@ var exportToSoul = (agentId, name, persona, state, memories) => {
 };
 var createAgent = (config) => {
   let state = createInitialState(config.initialState);
-  let memories = [];
   const cortex = config.cortex;
-  const apiUrl = config.apiUrl || "http://localhost:8080";
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
   const agentId = config.id || "agent-" + Math.random().toString(36).substring(7);
+  const authHeaders = config.apiKey ? { "Content-Type": "application/json", "Authorization": `Bearer ${config.apiKey}` } : { "Content-Type": "application/json" };
   const getAgentState = () => {
     return { ...state };
   };
@@ -56,7 +43,7 @@ var createAgent = (config) => {
     };
     const dirRes = await fetch(`${apiUrl}/agents/${agentId}/directive`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: authHeaders,
       body: JSON.stringify(directiveBody)
     });
     if (!dirRes.ok) {
@@ -68,7 +55,8 @@ var createAgent = (config) => {
       try {
         const rawMemories = await config.memory.recall(
           directiveData.memoryRecall.query,
-          directiveData.memoryRecall.limit
+          directiveData.memoryRecall.limit,
+          directiveData.memoryRecall.threshold
         );
         recalledMemories = rawMemories.map((m) => ({
           text: m.text,
@@ -76,7 +64,8 @@ var createAgent = (config) => {
           importance: m.importance,
           similarity: void 0
         }));
-      } catch {
+      } catch (e) {
+        console.warn("Memory recall failed, continuing with empty memories:", e);
       }
     }
     const contextBody = {
@@ -86,7 +75,7 @@ var createAgent = (config) => {
     };
     const ctxRes = await fetch(`${apiUrl}/agents/${agentId}/context`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: authHeaders,
       body: JSON.stringify(contextBody)
     });
     if (!ctxRes.ok) {
@@ -105,7 +94,7 @@ var createAgent = (config) => {
     };
     const verRes = await fetch(`${apiUrl}/agents/${agentId}/verdict`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: authHeaders,
       body: JSON.stringify(verdictBody)
     });
     if (!verRes.ok) {
@@ -120,8 +109,7 @@ var createAgent = (config) => {
     }
     if (config.memory && typeof config.memory.store === "function" && verdictData.memoryStore) {
       for (const instruction of verdictData.memoryStore) {
-        config.memory.store(instruction.text, instruction.type, instruction.importance).catch(() => {
-        });
+        config.memory.store(instruction.text, instruction.type, instruction.importance).catch((e) => console.warn("Memory store failed:", e));
       }
     }
     if (verdictData.stateDelta && Object.keys(verdictData.stateDelta).length > 0) {
@@ -136,18 +124,43 @@ var createAgent = (config) => {
       thought: generatedText
     };
   };
+  const speak = async (message, context = {}) => {
+    const currentState = getAgentState();
+    const speakBody = {
+      speakMessage: message,
+      speakContext: Object.keys(context).length > 0 ? context : void 0,
+      speakAgentState: currentState
+    };
+    const res = await fetch(`${apiUrl}/agents/${agentId}/speak`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify(speakBody)
+    });
+    if (!res.ok) {
+      throw new Error(`API Speak Error: ${res.status}`);
+    }
+    const data = await res.json();
+    if (data.speakHistory) {
+      state = updateAgentState(state, { conversationHistory: data.speakHistory });
+    }
+    return data.speakReply;
+  };
+  const reply = speak;
   const exportSoul2 = async () => {
-    let exportedMemories = [...memories];
+    let exportedMemories = [];
     if (config.memory && typeof config.memory.export === "function") {
       try {
         exportedMemories = await config.memory.export();
-      } catch {
+      } catch (e) {
+        console.warn("Memory export failed, exporting with empty memories:", e);
       }
     }
     return exportToSoul(agentId, "Agent", config.persona, state, exportedMemories);
   };
   return {
     process,
+    speak,
+    reply,
     getState: getAgentState,
     setState: setAgentState,
     export: exportSoul2
@@ -164,7 +177,8 @@ var fromSoul = async (soul, cortex, memory) => {
   if (memory && soul.memories && soul.memories.length > 0 && typeof memory.import === "function") {
     try {
       await memory.import(soul.memories);
-    } catch {
+    } catch (e) {
+      console.warn("Memory hydration failed, continuing without memories:", e);
     }
   }
   return agent;
@@ -218,10 +232,6 @@ var createBridge = (config = {}) => {
     for (const rule of applicableRules) {
       const result = rule.validate(currentAction, context);
       if (!result.valid) {
-        if (effectiveConfig.apiUrl) {
-          const apiResult = await validateRemote(action);
-          console.debug("API validation result:", apiResult);
-        }
         return result;
       }
       if (result.correctedAction) {
@@ -235,8 +245,6 @@ var createBridge = (config = {}) => {
   };
   const registerRule = (rule) => {
     rules.set(rule.id, rule);
-    if (effectiveConfig.apiUrl) {
-    }
   };
   const listRules = () => {
     return Array.from(rules.values());
@@ -264,7 +272,6 @@ var validateAction = (action, rules, context = {}) => {
 };
 
 // src/soul.ts
-import Irys from "@irys/sdk";
 var createSoul = (id, name, persona, state, memories = []) => {
   return {
     id,
@@ -294,63 +301,69 @@ var deserializeSoul = (json) => {
   };
 };
 var uploadToArweave = async (soul, config) => {
-  if (!config.privateKey) {
-    throw new Error("Private key required for direct Arweave upload");
+  const wallet = config.walletJwk || config.privateKey;
+  if (!wallet) {
+    throw new Error("Arweave wallet JWK required for direct upload");
   }
-  const irys = new Irys({
-    url: config.irysUrl || "https://node1.irys.xyz",
-    token: config.token || "solana",
-    key: config.privateKey
-  });
-  const dataToUpload = serializeSoul(soul);
+  let createArweaveDataItem;
   try {
-    const receipt = await irys.upload(dataToUpload);
-    return {
-      txId: receipt.id,
-      url: `https://gateway.irys.xyz/${receipt.id}`,
-      soul
-    };
+    const imported = await import("./ans104-GLQVFKBA.mjs");
+    createArweaveDataItem = imported.createArweaveDataItem;
   } catch (e) {
-    throw new Error(`Failed to upload to Arweave: ${e}`);
+    throw new Error("Missing ANS-104 Arweave module. Rebuild the SDK to enable direct uploads.");
   }
-};
-var exportSoul = async (agentId, soul, config = {}) => {
-  if (config.privateKey) {
-    try {
-      return await uploadToArweave(soul, config);
-    } catch (e) {
-      console.warn("Direct Arweave upload failed, falling back to API", e);
-    }
+  const jwk = typeof wallet === "string" ? JSON.parse(wallet) : wallet;
+  const dataToUpload = serializeSoul(soul);
+  const tags = [
+    { name: "Content-Type", value: "application/json" },
+    { name: "App-Name", value: "ForbocAI" },
+    { name: "App-Version", value: "soul-1" }
+  ];
+  const dataItem = await createArweaveDataItem(dataToUpload, jwk, { tags });
+  const rawData = dataItem.raw;
+  if (!rawData) {
+    throw new Error("Failed to build ANS-104 data item");
   }
-  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const bundlerUrl = config.bundlerUrl || "https://upload.ardrive.io/v1/tx";
+  const gatewayUrl = config.gatewayUrl || "https://arweave.net";
   try {
-    const response = await fetch(`${apiUrl}/agents/${agentId}/soul/export`, {
+    const response = await fetch(bundlerUrl, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ soul })
-      // Sending full soul for server to sign/upload
+      headers: { "Content-Type": "application/octet-stream" },
+      body: rawData
     });
     if (!response.ok) {
-      throw new Error(`Export failed: ${response.statusText}`);
+      const message = await response.text().catch(() => response.statusText);
+      throw new Error(message || response.statusText);
+    }
+    const responseText = await response.text();
+    let responseJson = null;
+    try {
+      responseJson = JSON.parse(responseText);
+    } catch {
+      responseJson = null;
+    }
+    const txId = responseJson?.id || responseJson?.dataItemId || responseJson?.txId || (typeof responseText === "string" && responseText.trim().length > 0 ? responseText.trim() : null) || dataItem.id;
+    if (!txId) {
+      throw new Error("Bundler response did not include a data item id");
     }
-    const data = await response.json();
     return {
-      txId: data.txId,
-      url: data.url,
+      txId,
+      url: `${gatewayUrl}/${txId}`,
       soul
     };
   } catch (e) {
-    console.warn("API export failed, returning mock Arweave TXID used for dev");
-    const mockTxId = `mock_ar_${Date.now()}`;
-    return {
-      txId: mockTxId,
-      url: `https://arweave.net/${mockTxId}`,
-      soul
-    };
+    throw new Error(`Failed to upload to Arweave: ${e}`);
   }
 };
+var exportSoul = async (_agentId, soul, config = {}) => {
+  if (!config.walletJwk && !config.privateKey) {
+    throw new Error("walletJwk required for Arweave ANS-104 export");
+  }
+  return uploadToArweave(soul, config);
+};
 var importSoulFromArweave = async (txId, config = {}) => {
-  const gateway = config.gatewayUrl || "https://gateway.irys.xyz";
+  const gateway = config.gatewayUrl || "https://arweave.net";
   try {
     const response = await fetch(`${gateway}/${txId}`, {
       method: "GET",
@@ -374,25 +387,22 @@ var getSoulList = async (limit = 50, apiUrl) => {
     const response = await fetch(`${url}/souls?limit=${limit}`);
     if (!response.ok) throw new Error(response.statusText);
     const data = await response.json();
-    return data.souls.map((s) => ({
-      txId: s.txId,
-      name: s.name,
-      agentId: s.agentId,
-      exportedAt: s.exportedAt,
-      url: s.url || `https://gateway.irys.xyz/${s.txId}`
-    }));
+    return data.souls.map((s) => {
+      const txId = s.txId || s.soulEntryTxId || s.cid;
+      const name = s.name || s.soulEntryName;
+      const agentId = s.agentId || s.soulEntryAgentId;
+      const exportedAt = s.exportedAt || s.soulEntryExportedAt;
+      const url2 = s.url || s.soulEntryArweaveUrl || `https://arweave.net/${txId}`;
+      return { txId, name, agentId, exportedAt, url: url2 };
+    });
   } catch (e) {
     return [];
   }
 };
-var createSoulInstance = (id, name, persona, state, memories = [], initialApiUrl) => {
+var createSoulInstance = (id, name, persona, state, memories = []) => {
   const soulData = createSoul(id, name, persona, state, memories);
-  const defaultApiUrl = initialApiUrl || "https://api.forboc.ai";
   const performExport = async (config) => {
-    return exportSoul(soulData.id, soulData, {
-      ...config,
-      apiUrl: config?.apiUrl || defaultApiUrl
-    });
+    return exportSoul(soulData.id, soulData, { ...config });
   };
   return {
     export: performExport,
@@ -604,6 +614,9 @@ var createGhost = (config) => {
     return getGhostResults(sessionId, apiUrl);
   };
   const stop = async () => {
+    if (sessionId) {
+      await stopGhostSession(sessionId, apiUrl);
+    }
     sessionId = null;
   };
   const waitForCompletion = async (pollIntervalMs, timeoutMs, onProgress) => {
@@ -628,7 +641,11 @@ var createGhost = (config) => {
 };
 
 // src/cortex-remote.ts
-var createRemoteCortex = (apiUrl) => {
+var createRemoteCortex = (apiUrl, cortexId = "local", apiKey) => {
+  const authHeaders = {
+    "Content-Type": "application/json",
+    ...apiKey ? { "Authorization": `Bearer ${apiKey}` } : {}
+  };
   const init = async () => ({
     id: `remote_${Date.now()}`,
     model: "api-integrated",
@@ -636,9 +653,9 @@ var createRemoteCortex = (apiUrl) => {
     engine: "remote"
   });
   const complete = async (prompt, options) => {
-    const response = await fetch(`${apiUrl}/cortex/complete`, {
+    const response = await fetch(`${apiUrl}/cortex/${cortexId}/complete`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: authHeaders,
       body: JSON.stringify({ prompt, ...options })
     });
     if (!response.ok) throw new Error(`Remote Cortex failed: ${response.statusText}`);
@@ -652,6 +669,42 @@ var createRemoteCortex = (apiUrl) => {
   return { init, complete, completeStream };
 };
 
+// src/stream.ts
+async function streamToCallback(stream, onChunk) {
+  for await (const chunk of stream) {
+    onChunk(chunk);
+  }
+}
+async function streamToString(stream) {
+  let fullText = "";
+  for await (const chunk of stream) {
+    fullText += chunk;
+  }
+  return fullText;
+}
+async function streamFromCortex(cortex, prompt, onChunk, options) {
+  const stream = cortex.completeStream(prompt, options);
+  let fullText = "";
+  for await (const chunk of stream) {
+    fullText += chunk;
+    onChunk(chunk);
+  }
+  return fullText;
+}
+async function streamFromCortexWithDelay(cortex, prompt, onChunk, options) {
+  const { delayMs = 30, ...completionOptions } = options ?? {};
+  const stream = cortex.completeStream(prompt, completionOptions);
+  let fullText = "";
+  for await (const chunk of stream) {
+    fullText += chunk;
+    onChunk(chunk);
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return fullText;
+}
+
 // src/presets/index.ts
 var presets_exports = {};
 __export(presets_exports, {
@@ -859,7 +912,7 @@ var socialRules = [speakRule, interactRule];
 var puzzleRules = [movementRule, interactRule];
 
 // src/index.ts
-var SDK_VERSION = "0.5.4";
+var SDK_VERSION = "0.5.7";
 export {
   SDK_VERSION,
   createAgent,
@@ -879,10 +932,13 @@ export {
   getSoulList,
   importSoulFromArweave,
   presets_exports as presets,
-  processAgentInput,
   serializeSoul,
   startGhostSession,
   stopGhostSession,
+  streamFromCortex,
+  streamFromCortexWithDelay,
+  streamToCallback,
+  streamToString,
   updateAgentState,
   uploadToArweave,
   validateAction,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forbocai/core",
-  "version": "0.5.4",
+  "version": "0.5.7",
   "license": "UNLICENSED",
   "description": "Core agnostic logic for ForbocAI SDK",
   "main": "dist/index.js",
@@ -12,7 +12,8 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@irys/sdk": "^0.1.1",
+    "arweave": "^1.15.7",
+    "base64url": "^3.0.1",
     "axios": "^1.6.2",
     "zod": "^3.22.4"
   },