@forbocai/core 0.5.4 → 0.5.7

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,236 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/ans104.ts
+var ans104_exports = {};
+__export(ans104_exports, {
+  createArweaveDataItem: () => createArweaveDataItem
+});
+var import_base64url, import_buffer, import_crypto, import_pem, SIGNATURE_TYPE_ARWEAVE, SIGNATURE_LENGTH, OWNER_LENGTH, MAX_TAG_BYTES, stringToBuffer, concatBuffers, longToNByteArray, longTo8ByteArray, shortTo2ByteArray, AVSCTap, serializeTags, hash, deepHash, deepHashChunks, getSignatureData, signData, getOwner, getPem, createArweaveDataItem;
+var init_ans104 = __esm({
+  "src/ans104.ts"() {
+    "use strict";
+    import_base64url = __toESM(require("base64url"));
+    import_buffer = require("buffer");
+    import_crypto = require("crypto");
+    import_pem = require("arweave/node/lib/crypto/pem");
+    SIGNATURE_TYPE_ARWEAVE = 1;
+    SIGNATURE_LENGTH = 512;
+    OWNER_LENGTH = 512;
+    MAX_TAG_BYTES = 4096;
+    stringToBuffer = (value) => import_buffer.Buffer.from(value);
+    concatBuffers = (buffers) => import_buffer.Buffer.concat(buffers);
+    longToNByteArray = (bytes, long) => {
+      const byteArray = new Uint8Array(bytes);
+      if (long < 0) throw new Error("Array is unsigned, cannot represent -ve numbers");
+      if (long > 2 ** (bytes * 8) - 1) throw new Error(`Number ${long} is too large for an array of ${bytes} bytes`);
+      for (let index = 0; index < byteArray.length; index++) {
+        const byte = long & 255;
+        byteArray[index] = byte;
+        long = (long - byte) / 256;
+      }
+      return byteArray;
+    };
+    longTo8ByteArray = (long) => longToNByteArray(8, long);
+    shortTo2ByteArray = (short) => longToNByteArray(2, short);
+    AVSCTap = class {
+      constructor(buf = import_buffer.Buffer.alloc(MAX_TAG_BYTES), pos = 0) {
+        this.buf = buf;
+        this.pos = pos;
+      }
+      writeTags(tags) {
+        if (!Array.isArray(tags)) {
+          throw new Error("input must be array");
+        }
+        const n = tags.length;
+        if (n) {
+          this.writeLong(n);
+          for (let i = 0; i < n; i++) {
+            const tag = tags[i];
+            if (typeof tag?.name !== "string" || typeof tag?.value !== "string") {
+              throw new Error(`Invalid tag format for ${tag}, expected {name:string, value: string}`);
+            }
+            this.writeString(tag.name);
+            this.writeString(tag.value);
+          }
+        }
+        this.writeLong(0);
+      }
+      toBuffer() {
+        const buffer = import_buffer.Buffer.alloc(this.pos);
+        if (this.pos > this.buf.length) throw new Error(`Too many tag bytes (${this.pos} > ${this.buf.length})`);
+        this.buf.copy(buffer, 0, 0, this.pos);
+        return buffer;
+      }
+      writeLong(n) {
+        const buf = this.buf;
+        let f, m;
+        if (n >= -1073741824 && n < 1073741824) {
+          m = n >= 0 ? n << 1 : ~n << 1 | 1;
+          do {
+            buf[this.pos] = m & 127;
+            m >>= 7;
+          } while (m && (buf[this.pos++] |= 128));
+        } else {
+          f = n >= 0 ? n * 2 : -n * 2 - 1;
+          do {
+            buf[this.pos] = f & 127;
+            f /= 128;
+          } while (f >= 1 && (buf[this.pos++] |= 128));
+        }
+        this.pos++;
+        this.buf = buf;
+      }
+      writeString(s) {
+        const len = import_buffer.Buffer.byteLength(s);
+        const buf = this.buf;
+        this.writeLong(len);
+        let pos = this.pos;
+        this.pos += len;
+        if (this.pos > buf.length) {
+          return;
+        }
+        if (len > 64) {
+          this.buf.write(s, this.pos - len, len, "utf8");
+        } else {
+          let i, l, c1, c2;
+          for (i = 0, l = len; i < l; i++) {
+            c1 = s.charCodeAt(i);
+            if (c1 < 128) {
+              buf[pos++] = c1;
+            } else if (c1 < 2048) {
+              buf[pos++] = c1 >> 6 | 192;
+              buf[pos++] = c1 & 63 | 128;
+            } else if ((c1 & 64512) === 55296 && ((c2 = s.charCodeAt(i + 1)) & 64512) === 56320) {
+              c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+              i++;
+              buf[pos++] = c1 >> 18 | 240;
+              buf[pos++] = c1 >> 12 & 63 | 128;
+              buf[pos++] = c1 >> 6 & 63 | 128;
+              buf[pos++] = c1 & 63 | 128;
+            } else {
+              buf[pos++] = c1 >> 12 | 224;
+              buf[pos++] = c1 >> 6 & 63 | 128;
+              buf[pos++] = c1 & 63 | 128;
+            }
+          }
+        }
+        this.buf = buf;
+      }
+    };
+    serializeTags = (tags) => {
+      if (tags?.length === 0) {
+        return import_buffer.Buffer.allocUnsafe(0);
+      }
+      const tap = new AVSCTap();
+      tap.writeTags(tags);
+      return tap.toBuffer();
+    };
+    hash = (data, algorithm) => {
+      const algo = algorithm === "SHA-256" ? "sha256" : "sha384";
+      return (0, import_crypto.createHash)(algo).update(data).digest();
+    };
+    deepHash = async (data) => {
+      if (Array.isArray(data)) {
+        const tag2 = concatBuffers([stringToBuffer("list"), stringToBuffer(data.length.toString())]);
+        return deepHashChunks(data, hash(tag2, "SHA-384"));
+      }
+      const _data = data;
+      const tag = concatBuffers([stringToBuffer("blob"), stringToBuffer(_data.byteLength.toString())]);
+      const taggedHash = concatBuffers([hash(tag, "SHA-384"), hash(_data, "SHA-384")]);
+      return hash(taggedHash, "SHA-384");
+    };
+    deepHashChunks = async (chunks, acc) => {
+      if (chunks.length < 1) {
+        return acc;
+      }
+      const hashPair = concatBuffers([acc, await deepHash(chunks[0])]);
+      const newAcc = hash(hashPair, "SHA-384");
+      return deepHashChunks(chunks.slice(1), newAcc);
+    };
+    getSignatureData = async (signatureType, rawOwner, rawTarget, rawAnchor, rawTags, rawData) => {
+      return deepHash([
+        stringToBuffer("dataitem"),
+        stringToBuffer("1"),
+        stringToBuffer(signatureType.toString()),
+        rawOwner,
+        rawTarget,
+        rawAnchor,
+        rawTags,
+        rawData
+      ]);
+    };
+    signData = async (pemKey, message) => {
+      return (0, import_crypto.createSign)("sha256").update(message).sign({
+        key: pemKey,
+        padding: import_crypto.constants.RSA_PKCS1_PSS_PADDING
+      });
+    };
+    getOwner = (jwk) => {
+      return import_base64url.default.toBuffer(jwk.n);
+    };
+    getPem = (jwk) => {
+      const pem = (0, import_pem.jwkTopem)(jwk);
+      return typeof pem === "string" ? pem : pem.toString();
+    };
+    createArweaveDataItem = async (data, jwk, opts) => {
+      const rawOwner = getOwner(jwk);
+      if (rawOwner.byteLength !== OWNER_LENGTH) {
+        throw new Error(`Owner must be ${OWNER_LENGTH} bytes, but was ${rawOwner.byteLength}`);
+      }
+      const rawTarget = opts?.target ? import_base64url.default.toBuffer(opts.target) : import_buffer.Buffer.alloc(0);
+      const rawAnchor = opts?.anchor ? import_buffer.Buffer.from(opts.anchor) : import_buffer.Buffer.alloc(0);
+      const rawTags = (opts?.tags?.length ?? 0) > 0 ? serializeTags(opts?.tags) : import_buffer.Buffer.alloc(0);
+      const rawData = typeof data === "string" ? import_buffer.Buffer.from(data) : import_buffer.Buffer.from(data);
+      const targetLength = 1 + (rawTarget?.byteLength ?? 0);
+      const anchorLength = 1 + (rawAnchor?.byteLength ?? 0);
+      const tagsLength = 16 + (rawTags ? rawTags.byteLength : 0);
+      const dataLength = rawData.byteLength;
+      const length = 2 + SIGNATURE_LENGTH + OWNER_LENGTH + targetLength + anchorLength + tagsLength + dataLength;
+      const bytes = import_buffer.Buffer.alloc(length);
+      bytes.set(shortTo2ByteArray(SIGNATURE_TYPE_ARWEAVE), 0);
+      bytes.set(new Uint8Array(SIGNATURE_LENGTH).fill(0), 2);
+      bytes.set(rawOwner, 2 + SIGNATURE_LENGTH);
+      const position = 2 + SIGNATURE_LENGTH + OWNER_LENGTH;
+      bytes[position] = rawTarget.length > 0 ? 1 : 0;
+      if (rawTarget.length > 0) {
+        if (rawTarget.byteLength !== 32) throw new Error("Target must be 32 bytes");
+        bytes.set(rawTarget, position + 1);
+      }
+      const anchorStart = position + targetLength;
+      let tagsStart = anchorStart + 1;
+      bytes[anchorStart] = rawAnchor.length > 0 ? 1 : 0;
+      if (rawAnchor.length > 0) {
+        tagsStart += rawAnchor.byteLength;
+        if (rawAnchor.byteLength !== 32) throw new Error("Anchor must be 32 bytes");
+        bytes.set(rawAnchor, anchorStart + 1);
+      }
+      bytes.set(longTo8ByteArray(opts?.tags?.length ?? 0), tagsStart);
+      bytes.set(longTo8ByteArray(rawTags?.byteLength ?? 0), tagsStart + 8);
+      if (rawTags.length > 0) {
+        bytes.set(rawTags, tagsStart + 16);
+      }
+      const dataStart = tagsStart + tagsLength;
+      bytes.set(rawData, dataStart);
+      const signatureData = await getSignatureData(
+        SIGNATURE_TYPE_ARWEAVE,
+        rawOwner,
+        rawTarget,
+        rawAnchor,
+        rawTags,
+        rawData
+      );
+      const signature = await signData(getPem(jwk), signatureData);
+      bytes.set(signature, 2);
+      const id = hash(signature, "SHA-256");
+      return {
+        id: import_base64url.default.encode(id),
+        raw: bytes
+      };
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -48,10 +281,13 @@ __export(index_exports, {
   getSoulList: () => getSoulList,
   importSoulFromArweave: () => importSoulFromArweave,
   presets: () => presets_exports,
-  processAgentInput: () => processAgentInput,
   serializeSoul: () => serializeSoul,
   startGhostSession: () => startGhostSession,
   stopGhostSession: () => stopGhostSession,
+  streamFromCortex: () => streamFromCortex,
+  streamFromCortexWithDelay: () => streamFromCortexWithDelay,
+  streamToCallback: () => streamToCallback,
+  streamToString: () => streamToString,
   updateAgentState: () => updateAgentState,
   uploadToArweave: () => uploadToArweave,
   validateAction: () => validateAction,
@@ -70,17 +306,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,
@@ -93,10 +318,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 };
   };
@@ -112,7 +337,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) {
@@ -124,7 +349,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,
@@ -132,7 +358,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 = {
@@ -142,7 +369,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) {
@@ -161,7 +388,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) {
@@ -176,8 +403,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) {
@@ -192,18 +418,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
@@ -220,7 +471,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;
@@ -274,10 +526,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) {
@@ -291,8 +539,6 @@ var createBridge = (config = {}) => {
   };
   const registerRule = (rule) => {
     rules.set(rule.id, rule);
-    if (effectiveConfig.apiUrl) {
-    }
   };
   const listRules = () => {
     return Array.from(rules.values());
@@ -320,7 +566,6 @@ var validateAction = (action, rules, context = {}) => {
 };
 
 // src/soul.ts
-var import_sdk = __toESM(require("@irys/sdk"));
 var createSoul = (id, name, persona, state, memories = []) => {
   return {
     id,
@@ -350,63 +595,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 import_sdk.default({
-    url: config.irysUrl || "https://node1.irys.xyz",
-    token: config.token || "solana",
-    key: config.privateKey
-  });
-  const dataToUpload = serializeSoul(soul);
+  let createArweaveDataItem2;
   try {
-    const receipt = await irys.upload(dataToUpload);
-    return {
-      txId: receipt.id,
-      url: `https://gateway.irys.xyz/${receipt.id}`,
-      soul
-    };
+    const imported = await Promise.resolve().then(() => (init_ans104(), ans104_exports));
+    createArweaveDataItem2 = 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 createArweaveDataItem2(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",
@@ -430,25 +681,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,
@@ -660,6 +908,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) => {
@@ -684,7 +935,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",
@@ -692,9 +947,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}`);
@@ -708,6 +963,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, {
@@ -915,7 +1206,7 @@ var socialRules = [speakRule, interactRule];
 var puzzleRules = [movementRule, interactRule];
 
 // src/index.ts
-var SDK_VERSION = "0.5.4";
+var SDK_VERSION = "0.5.7";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SDK_VERSION,
@@ -936,10 +1227,13 @@ var SDK_VERSION = "0.5.4";
   getSoulList,
   importSoulFromArweave,
   presets,
-  processAgentInput,
   serializeSoul,
   startGhostSession,
   stopGhostSession,
+  streamFromCortex,
+  streamFromCortexWithDelay,
+  streamToCallback,
+  streamToString,
   updateAgentState,
   uploadToArweave,
   validateAction,