@forbocai/core 0.5.6 → 0.5.8

package/dist/index.mjs

@@ -1,145 +1,123 @@
 import {
-  __export
-} from "./chunk-7P6ASYW6.mjs";
+  createSoul,
+  createSoulInstance,
+  deserializeSoul,
+  exportSoul,
+  getSoulList,
+  importSoulFromArweave,
+  serializeSoul,
+  validateSoul
+} from "./chunk-M3F3ED7H.mjs";
 
 // src/agent.ts
-var createInitialState = (partial) => {
-  return { ...partial };
-};
-var updateAgentState = (currentState, updates) => {
-  return {
-    ...currentState,
-    ...updates
-  };
-};
-var exportToSoul = (agentId, name, persona, state, memories) => {
-  return {
-    id: agentId,
-    version: "1.0.0",
-    name,
-    persona,
-    memories: [...memories],
-    state: { ...state }
-  };
+var createInitialState = (partial) => ({ ...partial });
+var updateAgentState = (currentState, updates) => ({
+  ...currentState,
+  ...updates
+});
+var exportToSoul = (agentId, name, persona, state, memories) => ({
+  id: agentId,
+  version: "1.0.0",
+  name,
+  persona,
+  memories: [...memories],
+  state: { ...state }
+});
+var storeMemoriesRecursive = async (memory, instructions, index = 0) => {
+  if (index >= instructions.length) return;
+  const { text, type, importance } = instructions[index];
+  await memory.store(text, type, importance).catch((e) => console.warn("Memory store failed:", e));
+  return storeMemoriesRecursive(memory, instructions, index + 1);
 };
 var createAgent = (config) => {
-  let state = createInitialState(config.initialState);
+  let _state = createInitialState(config.initialState);
   const cortex = config.cortex;
   const apiUrl = config.apiUrl || "https://api.forboc.ai";
   const agentId = config.id || "agent-" + Math.random().toString(36).substring(7);
-  const getAgentState = () => {
-    return { ...state };
-  };
-  const setAgentState = (newState) => {
-    state = newState;
+  const authHeaders = config.apiKey ? { "Content-Type": "application/json", "Authorization": `Bearer ${config.apiKey}` } : { "Content-Type": "application/json" };
+  const getState = () => ({ ..._state });
+  const setState = (newState) => {
+    _state = newState;
   };
   const process = async (input, context = {}) => {
-    const currentState = getAgentState();
-    const directiveBody = {
-      observation: input,
-      agentState: currentState,
-      context
-    };
+    const currentState = getState();
     const dirRes = await fetch(`${apiUrl}/agents/${agentId}/directive`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(directiveBody)
+      headers: authHeaders,
+      body: JSON.stringify({ observation: input, agentState: currentState, context })
     });
-    if (!dirRes.ok) {
-      throw new Error(`API Directive Error: ${dirRes.status}`);
-    }
+    if (!dirRes.ok) throw new Error(`API Directive Error: ${dirRes.status}`);
     const directiveData = await dirRes.json();
-    let recalledMemories = [];
-    if (config.memory && typeof config.memory.recall === "function") {
-      try {
-        const rawMemories = await config.memory.recall(
-          directiveData.memoryRecall.query,
-          directiveData.memoryRecall.limit,
-          directiveData.memoryRecall.threshold
-        );
-        recalledMemories = rawMemories.map((m) => ({
-          text: m.text,
-          type: m.type,
-          importance: m.importance,
-          similarity: void 0
-        }));
-      } catch (e) {
-        console.warn("Memory recall failed, continuing with empty memories:", e);
-      }
-    }
-    const contextBody = {
-      memories: recalledMemories,
-      observation: input,
-      agentState: currentState
-    };
+    const recalledMemories = config.memory && directiveData.memoryRecall ? await config.memory.recall(
+      directiveData.memoryRecall.query,
+      directiveData.memoryRecall.limit,
+      directiveData.memoryRecall.threshold
+    ).then((mems) => mems.map((m) => ({ text: m.text, type: m.type, importance: m.importance, similarity: void 0 }))).catch(() => []) : [];
     const ctxRes = await fetch(`${apiUrl}/agents/${agentId}/context`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(contextBody)
+      headers: authHeaders,
+      body: JSON.stringify({ memories: recalledMemories, observation: input, agentState: currentState })
     });
-    if (!ctxRes.ok) {
-      throw new Error(`API Context Error: ${ctxRes.status}`);
-    }
+    if (!ctxRes.ok) throw new Error(`API Context Error: ${ctxRes.status}`);
     const contextData = await ctxRes.json();
     const generatedText = await cortex.complete(contextData.prompt, {
       maxTokens: contextData.constraints.maxTokens,
       temperature: contextData.constraints.temperature,
       stop: contextData.constraints.stop
     });
-    const verdictBody = {
-      generatedOutput: generatedText,
-      observation: input,
-      agentState: currentState
-    };
     const verRes = await fetch(`${apiUrl}/agents/${agentId}/verdict`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(verdictBody)
+      headers: authHeaders,
+      body: JSON.stringify({ generatedOutput: generatedText, observation: input, agentState: currentState })
     });
-    if (!verRes.ok) {
-      throw new Error(`API Verdict Error: ${verRes.status}`);
-    }
+    if (!verRes.ok) throw new Error(`API Verdict Error: ${verRes.status}`);
     const verdictData = await verRes.json();
     if (!verdictData.valid) {
-      return {
-        dialogue: "... [Action Blocked by Protocol]",
-        action: { type: "BLOCKED", reason: "API Validation Failed" }
-      };
+      return { dialogue: "... [Blocked]", action: { type: "BLOCKED", reason: "Validation Failed" } };
     }
-    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((e) => console.warn("Memory store failed:", e));
-      }
+    if (config.memory && verdictData.memoryStore) {
+      storeMemoriesRecursive(config.memory, verdictData.memoryStore);
     }
-    if (verdictData.stateDelta && Object.keys(verdictData.stateDelta).length > 0) {
-      state = updateAgentState(state, verdictData.stateDelta);
+    if (verdictData.stateDelta) {
+      setState(updateAgentState(_state, verdictData.stateDelta));
     }
     return {
       dialogue: generatedText,
-      action: verdictData.action ? {
-        ...verdictData.action,
-        signature: verdictData.signature
-      } : void 0,
+      action: verdictData.action ? { ...verdictData.action, signature: verdictData.signature } : void 0,
       thought: generatedText
     };
   };
+  const speak = async (message, context = {}) => {
+    const res = await fetch(`${apiUrl}/agents/${agentId}/speak`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({ speakMessage: message, speakContext: context, speakAgentState: getState() })
+    });
+    if (!res.ok) throw new Error(`API Speak Error: ${res.status}`);
+    const data = await res.json();
+    if (data.speakHistory) setState(updateAgentState(_state, { conversationHistory: data.speakHistory }));
+    return data.speakReply;
+  };
+  const dialogue = async (message, context = []) => {
+    const res = await fetch(`${apiUrl}/agents/${agentId}/dialogue`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({ diagMessage: message, diagContext: context })
+    });
+    if (!res.ok) throw new Error(`API Dialogue Error: ${res.status}`);
+    const data = await res.json();
+    return data.diagReply;
+  };
   const exportSoul2 = async () => {
-    let exportedMemories = [];
-    if (config.memory && typeof config.memory.export === "function") {
-      try {
-        exportedMemories = await config.memory.export();
-      } catch (e) {
-        console.warn("Memory export failed, exporting with empty memories:", e);
-      }
-    }
-    return exportToSoul(agentId, "Agent", config.persona, state, exportedMemories);
+    const memories = config.memory ? await config.memory.export().catch(() => []) : [];
+    return exportToSoul(agentId, "Agent", config.persona, _state, memories);
   };
-  return {
-    process,
-    getState: getAgentState,
-    setState: setAgentState,
-    export: exportSoul2
+  const exportSoulToArweave = async (soulConfig) => {
+    const soul = await exportSoul2();
+    const { exportSoul: exportFunc } = await import("./soul-QXKV5H2R.mjs");
+    return exportFunc(agentId, soul, { ...soulConfig, apiUrl });
   };
+  return { process, speak, dialogue, reply: speak, getState, setState, export: exportSoul2, exportSoul: exportSoulToArweave };
 };
 var fromSoul = async (soul, cortex, memory) => {
   const agent = createAgent({
@@ -149,412 +127,177 @@ var fromSoul = async (soul, cortex, memory) => {
     persona: soul.persona,
     initialState: soul.state
   });
-  if (memory && soul.memories && soul.memories.length > 0 && typeof memory.import === "function") {
-    try {
-      await memory.import(soul.memories);
-    } catch (e) {
-      console.warn("Memory hydration failed, continuing without memories:", e);
-    }
+  if (memory && soul.memories && soul.memories.length > 0) {
+    await memory.import(soul.memories).catch((e) => console.warn("Memory hydration failed:", e));
   }
   return agent;
 };
 
 // src/bridge.ts
 var createBridge = (config = {}) => {
-  const effectiveConfig = {
-    strictMode: config.strictMode ?? false,
-    ...config
-  };
-  const rules = /* @__PURE__ */ new Map();
-  if (config.customRules) {
-    config.customRules.forEach((rule) => rules.set(rule.id, rule));
-  }
-  const validateRemote = async (action) => {
-    const response = await fetch(`${effectiveConfig.apiUrl}/bridge/validate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        actionType: action.type,
-        payload: JSON.stringify(action.payload || {})
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`API validation failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      valid: data.valid,
-      reason: data.reason
-    };
-  };
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const agentId = config.agentId;
   const validate = async (action, context = {}) => {
-    const applicableRules = Array.from(rules.values()).filter(
-      (rule) => rule.actionTypes.some(
-        (t) => t.toLowerCase() === action.type.toLowerCase()
-      )
-    );
-    if (effectiveConfig.strictMode && applicableRules.length === 0) {
-      const safeTypes = ["IDLE", "idle", "WAIT", "wait"];
-      if (!safeTypes.includes(action.type)) {
-        return {
-          valid: false,
-          reason: `Unknown action type '${action.type}' in strict mode`,
-          correctedAction: { ...action, type: "IDLE", reason: "Unknown action type" }
-        };
-      }
-    }
-    let currentAction = action;
-    for (const rule of applicableRules) {
-      const result = rule.validate(currentAction, context);
-      if (!result.valid) {
-        return result;
-      }
-      if (result.correctedAction) {
-        currentAction = result.correctedAction;
+    const endpoint = agentId ? `${apiUrl}/bridge/validate/${agentId}` : `${apiUrl}/bridge/validate`;
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action, context })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Bridge validation failed: ${error}`);
       }
+      const data = await response.json();
+      return data.brResult || data;
+    } catch (e) {
+      console.error("[Bridge] Validation error:", e);
+      return {
+        valid: false,
+        reason: `Network error reaching validation API: ${e instanceof Error ? e.message : String(e)}`
+      };
     }
-    return {
-      valid: true,
-      correctedAction: currentAction !== action ? currentAction : void 0
-    };
-  };
-  const registerRule = (rule) => {
-    rules.set(rule.id, rule);
-  };
-  const listRules = () => {
-    return Array.from(rules.values());
   };
-  const removeRule = (ruleId) => {
-    return rules.delete(ruleId);
-  };
-  return {
-    validate,
-    registerRule,
-    listRules,
-    removeRule
+  const listRulesets = async () => {
+    const response = await fetch(`${apiUrl}/rules`);
+    if (!response.ok) return [];
+    return response.json();
   };
+  return { validate, listRulesets };
 };
-var validateAction = (action, rules, context = {}) => {
-  for (const rule of rules) {
-    if (rule.actionTypes.some((t) => t.toLowerCase() === action.type.toLowerCase())) {
-      const result = rule.validate(action, context);
-      if (!result.valid) {
-        return result;
-      }
-    }
+var validateAction = async (action, context = {}, config = {}) => {
+  const bridge = createBridge(config);
+  return bridge.validate(action, context);
+};
+var loadPreset = async (presetName, apiUrl = "https://api.forboc.ai") => {
+  const response = await fetch(`${apiUrl}/rules/presets/${presetName}`, {
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to load preset '${presetName}': ${response.statusText}`);
   }
-  return { valid: true };
+  return response.json();
 };
 
-// src/soul.ts
-var createSoul = (id, name, persona, state, memories = []) => {
-  return {
-    id,
-    version: "1.0.0",
-    name,
-    persona,
-    state: { ...state },
-    memories: [...memories]
+// src/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var pipe = (...fns) => (initialValue) => fns.reduce((acc, fn) => fn(acc), initialValue);
+var memoiseAsync = (fn) => {
+  let cached = null;
+  let promise = null;
+  return () => {
+    if (cached) return Promise.resolve(cached);
+    if (promise) return promise;
+    promise = fn().then((value) => {
+      cached = value;
+      return value;
+    });
+    return promise;
   };
 };
-var serializeSoul = (soul) => {
-  return JSON.stringify(soul, null, 2);
+var memoise = (fn) => {
+  let cached = null;
+  let initialized = false;
+  return () => {
+    if (initialized) return cached;
+    cached = fn();
+    initialized = true;
+    return cached;
+  };
 };
-var deserializeSoul = (json) => {
-  const parsed = JSON.parse(json);
-  if (!parsed.id || !parsed.persona || !parsed.state) {
-    throw new Error("Invalid Soul format: missing required fields");
-  }
+
+// src/ghost.ts
+var DEFAULT_API_URL = "https://api.forboc.ai";
+var startGhostSession = async (config) => {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${apiUrl}/ghost/run`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      testSuite: config.testSuite,
+      duration: config.duration
+    })
+  });
+  if (!response.ok) throw new Error(`Failed to start Ghost: ${response.statusText}`);
+  const data = await response.json();
   return {
-    id: parsed.id,
-    version: parsed.version || "1.0.0",
-    name: parsed.name || "Unknown",
-    persona: parsed.persona,
-    state: parsed.state,
-    memories: parsed.memories || [],
-    signature: parsed.signature
+    sessionId: data.sessionId,
+    status: data.runStatus
   };
 };
-var uploadToArweave = async (soul, config) => {
-  const wallet = config.walletJwk || config.privateKey;
-  if (!wallet) {
-    throw new Error("Arweave wallet JWK required for direct upload");
-  }
-  let createArweaveDataItem;
-  try {
-    const imported = await import("./ans104-GLQVFKBA.mjs");
-    createArweaveDataItem = imported.createArweaveDataItem;
-  } catch (e) {
-    throw new Error("Missing ANS-104 Arweave module. Rebuild the SDK to enable direct uploads.");
-  }
-  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 bundlerUrl = config.bundlerUrl || "https://upload.ardrive.io/v1/tx";
-  const gatewayUrl = config.gatewayUrl || "https://arweave.net";
-  try {
-    const response = await fetch(bundlerUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/octet-stream" },
-      body: rawData
-    });
-    if (!response.ok) {
-      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");
-    }
-    return {
-      txId,
-      url: `${gatewayUrl}/${txId}`,
-      soul
-    };
-  } catch (e) {
-    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://arweave.net";
-  try {
-    const response = await fetch(`${gateway}/${txId}`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Import failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!data.id || !data.persona) {
-      throw new Error("Invalid soul data from Arweave");
-    }
-    return data;
-  } catch (e) {
-    throw new Error(`Failed to import Soul from TXID ${txId}: ${e}`);
-  }
-};
-var getSoulList = async (limit = 50, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
-  try {
-    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) => {
-      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 = []) => {
-  const soulData = createSoul(id, name, persona, state, memories);
-  const performExport = async (config) => {
-    return exportSoul(soulData.id, soulData, { ...config });
-  };
+var getGhostStatus = async (sessionId, apiUrl) => {
+  const url = apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${url}/ghost/${sessionId}/status`, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) throw new Error(`Failed to get status: ${response.statusText}`);
+  const data = await response.json();
   return {
-    export: performExport,
-    toJSON: () => ({ ...soulData })
+    sessionId: data.ghostSessionId,
+    status: data.ghostStatus,
+    progress: data.ghostProgress,
+    startedAt: data.ghostStartedAt,
+    duration: data.ghostDuration,
+    errors: data.ghostErrors
   };
 };
-var validateSoul = (soul) => {
-  const errors = [];
-  if (!soul.id) errors.push("Missing id");
-  if (!soul.persona) errors.push("Missing persona");
-  if (!soul.state) errors.push("Missing state");
+var getGhostResults = async (sessionId, apiUrl) => {
+  const url = apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${url}/ghost/${sessionId}/results`, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) throw new Error(`Failed to get results: ${response.statusText}`);
+  const data = await response.json();
   return {
-    valid: errors.length === 0,
-    errors
+    sessionId: data.resultsSessionId,
+    totalTests: data.resultsTotalTests,
+    passed: data.resultsPassed,
+    failed: data.resultsFailed,
+    skipped: data.resultsSkipped,
+    duration: data.resultsDuration,
+    tests: data.resultsTests.map((t) => ({
+      name: t.testName,
+      passed: t.testPassed,
+      duration: t.testDuration,
+      error: t.testError,
+      screenshot: t.testScreenshot
+    })),
+    coverage: data.resultsCoverage,
+    metrics: Object.fromEntries(data.resultsMetrics || [])
   };
 };
-
-// src/ghost.ts
-var startGhostSession = async (config) => {
-  const apiUrl = config.apiUrl || "https://api.forboc.ai";
-  try {
-    const response = await fetch(`${apiUrl}/ghost/run`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        testSuite: config.testSuite,
-        duration: config.duration
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to start Ghost session: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      sessionId: data.sessionId,
-      status: data.runStatus
-    };
-  } catch (e) {
-    const mockId = `ghost_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-    return {
-      sessionId: mockId,
-      status: "running"
-    };
+var pollForCompletion = async (sessionId, pollIntervalMs, timeoutMs, startTime, apiUrl, onProgress) => {
+  if (Date.now() - startTime > timeoutMs) {
+    throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
   }
-};
-var getGhostStatus = async (sessionId, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
   try {
-    const response = await fetch(`${url}/ghost/${sessionId}/status`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get Ghost status: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      sessionId: data.ghostSessionId,
-      status: data.ghostStatus,
-      progress: data.ghostProgress,
-      startedAt: data.ghostStartedAt,
-      duration: data.ghostDuration,
-      errors: data.ghostErrors
-    };
+    const status = await getGhostStatus(sessionId, apiUrl);
+    if (onProgress) onProgress(status);
+    if (status.status === "completed") return getGhostResults(sessionId, apiUrl);
+    if (status.status === "failed") throw new Error(`Ghost session failed with ${status.errors} errors`);
   } catch (e) {
-    return {
-      sessionId,
-      status: "running",
-      progress: Math.floor(Math.random() * 100),
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      duration: 60,
-      errors: 0
-    };
   }
+  await delay(pollIntervalMs);
+  return pollForCompletion(sessionId, pollIntervalMs, timeoutMs, startTime, apiUrl, onProgress);
 };
-var getGhostResults = async (sessionId, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
-  try {
-    const response = await fetch(`${url}/ghost/${sessionId}/results`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get Ghost results: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      sessionId: data.resultsSessionId,
-      totalTests: data.resultsTotalTests,
-      passed: data.resultsPassed,
-      failed: data.resultsFailed,
-      skipped: data.resultsSkipped,
-      duration: data.resultsDuration,
-      tests: data.resultsTests.map((t) => ({
-        name: t.testName,
-        passed: t.testPassed,
-        duration: t.testDuration,
-        error: t.testError,
-        screenshot: t.testScreenshot
-      })),
-      coverage: data.resultsCoverage,
-      metrics: Object.fromEntries(data.resultsMetrics)
-    };
-  } catch (e) {
-    return {
-      sessionId,
-      totalTests: 5,
-      passed: 4,
-      failed: 1,
-      skipped: 0,
-      duration: 1245,
-      tests: [
-        { name: "test.navigation", passed: true, duration: 150 },
-        { name: "test.combat", passed: true, duration: 230 },
-        { name: "test.dialogue", passed: false, duration: 450, error: "Timeout" }
-      ],
-      coverage: 0.75,
-      metrics: {
-        avgFrameRate: 58.5,
-        memoryUsageMB: 512.3,
-        aiDecisionsPerSec: 15.2
-      }
-    };
-  }
-};
-var waitForGhostCompletion = async (sessionId, pollIntervalMs = 5e3, timeoutMs = 3e5, apiUrl, onProgress) => {
-  const startTime = Date.now();
-  while (Date.now() - startTime < timeoutMs) {
-    try {
-      const status = await getGhostStatus(sessionId, apiUrl);
-      if (onProgress) {
-        onProgress(status);
-      }
-      if (status.status === "completed") {
-        return getGhostResults(sessionId, apiUrl);
-      }
-      if (status.status === "failed") {
-        throw new Error(`Ghost session failed with ${status.errors} errors`);
-      }
-    } catch (e) {
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-  }
-  throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
-};
+var waitForGhostCompletion = (sessionId, pollIntervalMs = 5e3, timeoutMs = 3e5, apiUrl, onProgress) => pollForCompletion(sessionId, pollIntervalMs, timeoutMs, Date.now(), apiUrl, onProgress);
 var stopGhostSession = async (sessionId, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
+  const url = apiUrl || DEFAULT_API_URL;
   try {
-    const response = await fetch(`${url}/ghost/${sessionId}/stop`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to stop Ghost session: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      stopped: true,
-      status: data.status || "stopped"
-    };
+    const response = await fetch(`${url}/ghost/${sessionId}/stop`, { method: "POST" });
+    return { stopped: response.ok };
   } catch (e) {
-    return {
-      stopped: true,
-      status: "stopped"
-    };
+    return { stopped: true };
   }
 };
 var getGhostHistory = async (limit = 10, apiUrl) => {
-  const url = apiUrl || "https://api.forboc.ai";
+  const url = apiUrl || DEFAULT_API_URL;
   try {
-    const response = await fetch(`${url}/ghost/history?limit=${limit}`, {
-      method: "GET",
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get Ghost history: ${response.statusText}`);
-    }
+    const response = await fetch(`${url}/ghost/history?limit=${limit}`);
+    if (!response.ok) return [];
     const data = await response.json();
     return data.sessions.map((s) => ({
       sessionId: s.sessionId,
@@ -569,54 +312,33 @@ var getGhostHistory = async (limit = 10, apiUrl) => {
   }
 };
 var createGhost = (config) => {
-  let sessionId = null;
-  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  let _sessionId = null;
+  const apiUrl = config.apiUrl || DEFAULT_API_URL;
   const run = async () => {
     const result = await startGhostSession(config);
-    sessionId = result.sessionId;
-    return sessionId;
+    _sessionId = result.sessionId;
+    return _sessionId;
   };
-  const status = async () => {
-    if (!sessionId) {
-      throw new Error("Ghost session not started");
-    }
-    return getGhostStatus(sessionId, apiUrl);
-  };
-  const results = async () => {
-    if (!sessionId) {
-      throw new Error("Ghost session not started");
-    }
-    return getGhostResults(sessionId, apiUrl);
+  const ensureSessionId = () => {
+    if (!_sessionId) throw new Error("Ghost session not started");
+    return _sessionId;
   };
+  const status = async () => getGhostStatus(ensureSessionId(), apiUrl);
+  const results = async () => getGhostResults(ensureSessionId(), apiUrl);
   const stop = async () => {
-    if (sessionId) {
-      await stopGhostSession(sessionId, apiUrl);
-    }
-    sessionId = null;
-  };
-  const waitForCompletion = async (pollIntervalMs, timeoutMs, onProgress) => {
-    if (!sessionId) {
-      throw new Error("Ghost session not started");
-    }
-    return waitForGhostCompletion(
-      sessionId,
-      pollIntervalMs,
-      timeoutMs,
-      apiUrl,
-      onProgress
-    );
-  };
-  return {
-    run,
-    status,
-    results,
-    stop,
-    waitForCompletion
+    if (_sessionId) await stopGhostSession(_sessionId, apiUrl);
+    _sessionId = null;
   };
+  const waitForCompletion = (pollIntervalMs, timeoutMs, onProgress) => waitForGhostCompletion(ensureSessionId(), pollIntervalMs, timeoutMs, apiUrl, onProgress);
+  return { run, status, results, stop, waitForCompletion };
 };
 
 // src/cortex-remote.ts
-var createRemoteCortex = (apiUrl, cortexId = "local") => {
+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",
@@ -626,7 +348,7 @@ var createRemoteCortex = (apiUrl, cortexId = "local") => {
   const complete = async (prompt, options) => {
     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}`);
@@ -640,214 +362,32 @@ var createRemoteCortex = (apiUrl, cortexId = "local") => {
   return { init, complete, completeStream };
 };
 
-// src/presets/index.ts
-var presets_exports = {};
-__export(presets_exports, {
-  RPG_MEMORY_TYPES: () => RPG_MEMORY_TYPES,
-  RPG_MOODS: () => RPG_MOODS,
-  attackRule: () => attackRule,
-  createRPGState: () => createRPGState,
-  interactRule: () => interactRule,
-  movementRule: () => movementRule,
-  puzzleRules: () => puzzleRules,
-  resourceRule: () => resourceRule,
-  rpgRules: () => rpgRules,
-  socialRules: () => socialRules,
-  spatialRules: () => spatialRules,
-  speakRule: () => speakRule
-});
-
-// src/presets/rpg.ts
-var RPG_MOODS = {
-  hostile: "hostile",
-  suspicious: "suspicious",
-  neutral: "neutral",
-  friendly: "friendly",
-  loyal: "loyal"
-};
-var RPG_MEMORY_TYPES = {
-  observation: "observation",
-  experience: "experience",
-  knowledge: "knowledge",
-  emotion: "emotion"
-};
-var createRPGState = (partial) => {
-  return {
-    inventory: partial?.inventory ?? [],
-    hp: partial?.hp ?? 100,
-    mana: partial?.mana ?? 100,
-    skills: partial?.skills ?? {},
-    relationships: partial?.relationships ?? {},
-    mood: partial?.mood ?? "neutral",
-    ...partial
-  };
-};
-var movementRule = {
-  id: "core.movement",
-  name: "Movement Validation",
-  description: "Ensures MOVE actions have valid x,y coordinates",
-  actionTypes: ["MOVE", "move"],
-  validate: (action, context) => {
-    const payload = action.payload || {};
-    const target = payload.target;
-    if (!target || typeof target.x !== "number" || typeof target.y !== "number") {
-      return {
-        valid: false,
-        reason: "MOVE action must have target with numeric x,y coordinates",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid MOVE target - defaulting to IDLE"
-        }
-      };
-    }
-    const world = context.worldState || {};
-    const maxX = world.maxX || Infinity;
-    const maxY = world.maxY || Infinity;
-    if (target.x < 0 || target.x > maxX || target.y < 0 || target.y > maxY) {
-      return {
-        valid: false,
-        reason: `MOVE target (${target.x}, ${target.y}) is out of bounds`,
-        correctedAction: {
-          ...action,
-          payload: {
-            ...payload,
-            target: {
-              x: Math.max(0, Math.min(maxX, target.x)),
-              y: Math.max(0, Math.min(maxY, target.y))
-            }
-          }
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var attackRule = {
-  id: "core.attack",
-  name: "Attack Validation",
-  description: "Ensures ATTACK actions have valid targetId",
-  actionTypes: ["ATTACK", "attack"],
-  validate: (action, context) => {
-    if (!action.target && !action.payload?.targetId) {
-      return {
-        valid: false,
-        reason: "ATTACK action must have a target or targetId",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid ATTACK - no target specified"
-        }
-      };
-    }
-    const world = context.worldState || {};
-    const entities = world.entities || [];
-    const targetId = action.target || action.payload?.targetId;
-    if (entities.length > 0 && !entities.includes(targetId)) {
-      return {
-        valid: false,
-        reason: `ATTACK target '${targetId}' does not exist in world`,
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Target not found"
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var interactRule = {
-  id: "core.interact",
-  name: "Interact Validation",
-  description: "Ensures INTERACT actions have valid objectId",
-  actionTypes: ["INTERACT", "interact"],
-  validate: (action, context) => {
-    if (!action.target && !action.payload?.objectId) {
-      return {
-        valid: false,
-        reason: "INTERACT action must have objectId",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid INTERACT - no object specified"
-        }
-      };
-    }
-    return { valid: true };
-  }
+// src/stream.ts
+var consumeStream = async (stream, onChunk, acc = "", delayMs = 0) => {
+  const { value, done } = await stream.next();
+  if (done) return acc;
+  const chunk = value ?? "";
+  onChunk(chunk);
+  if (delayMs > 0) await delay(delayMs);
+  return consumeStream(stream, onChunk, acc + chunk, delayMs);
+};
+var streamToCallback = async (stream, onChunk) => {
+  await consumeStream(stream, onChunk);
+};
+var streamToString = async (stream) => {
+  return consumeStream(stream, () => {
+  });
 };
-var speakRule = {
-  id: "core.speak",
-  name: "Speak Validation",
-  description: "Ensures SPEAK actions have non-empty text",
-  actionTypes: ["SPEAK", "speak"],
-  validate: (action, context) => {
-    const text = action.payload?.text;
-    if (!text || text.trim().length === 0) {
-      return {
-        valid: false,
-        reason: "SPEAK action must have non-empty text",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Empty speech - defaulting to IDLE"
-        }
-      };
-    }
-    const maxLength = context.constraints?.maxSpeechLength || 1e3;
-    if (text.length > maxLength) {
-      return {
-        valid: true,
-        reason: `Speech truncated to ${maxLength} characters`,
-        correctedAction: {
-          ...action,
-          payload: {
-            ...action.payload,
-            text: text.substring(0, maxLength)
-          }
-        }
-      };
-    }
-    return { valid: true };
-  }
+var streamFromCortex = async (cortex, prompt, onChunk, options) => {
+  return consumeStream(cortex.completeStream(prompt, options), onChunk);
 };
-var resourceRule = {
-  id: "core.resources",
-  name: "Resource Validation",
-  description: "Ensures agent has required resources for action",
-  actionTypes: ["ATTACK", "CAST", "USE_ITEM"],
-  validate: (action, context) => {
-    const agent = context.agentState || {};
-    const hp = agent.hp ?? 100;
-    const mana = agent.mana ?? 100;
-    if (hp <= 0) {
-      return {
-        valid: false,
-        reason: "Agent is dead and cannot perform actions",
-        correctedAction: { ...action, type: "IDLE", reason: "Agent dead" }
-      };
-    }
-    if (action.type === "CAST" || action.type === "cast") {
-      const manaCost = action.payload?.manaCost || 10;
-      if (mana < manaCost) {
-        return {
-          valid: false,
-          reason: `Insufficient mana: need ${manaCost}, have ${mana}`,
-          correctedAction: { ...action, type: "IDLE", reason: "Not enough mana" }
-        };
-      }
-    }
-    return { valid: true };
-  }
+var streamFromCortexWithDelay = async (cortex, prompt, onChunk, options) => {
+  const { delayMs = 30, ...completionOptions } = options ?? {};
+  return consumeStream(cortex.completeStream(prompt, completionOptions), onChunk, "", delayMs);
 };
-var rpgRules = [movementRule, attackRule, interactRule, speakRule, resourceRule];
-var spatialRules = [movementRule];
-var socialRules = [speakRule, interactRule];
-var puzzleRules = [movementRule, interactRule];
 
 // src/index.ts
-var SDK_VERSION = "0.5.6";
+var SDK_VERSION = "0.5.7";
 export {
   SDK_VERSION,
   createAgent,
@@ -857,6 +397,7 @@ export {
   createRemoteCortex,
   createSoul,
   createSoulInstance,
+  delay,
   deserializeSoul,
   exportSoul,
   exportToSoul,
@@ -866,12 +407,18 @@ export {
   getGhostStatus,
   getSoulList,
   importSoulFromArweave,
-  presets_exports as presets,
+  loadPreset,
+  memoise,
+  memoiseAsync,
+  pipe,
   serializeSoul,
   startGhostSession,
   stopGhostSession,
+  streamFromCortex,
+  streamFromCortexWithDelay,
+  streamToCallback,
+  streamToString,
   updateAgentState,
-  uploadToArweave,
   validateAction,
   validateSoul,
   waitForGhostCompletion