@forbocai/core 0.6.2 → 0.6.3

package/dist/index.js

@@ -54,6 +54,8 @@ __export(index_exports, {
   getGhostStatusThunk: () => getGhostStatusThunk,
   getSoulListThunk: () => getSoulListThunk,
   ghostSlice: () => ghostSlice,
+  handler_ArweaveDownload: () => handler_ArweaveDownload,
+  handler_ArweaveUpload: () => handler_ArweaveUpload,
   importNpcFromSoulThunk: () => importNpcFromSoulThunk,
   importSoulFromArweaveThunk: () => importSoulFromArweaveThunk,
   initRemoteCortexThunk: () => initRemoteCortexThunk,
@@ -325,6 +327,16 @@ var sdkApi = (0, import_query.createApi)({
       invalidatesTags: ["Soul"],
       transformResponse: (response) => response
     }),
+    postSoulExportConfirm: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/soul/confirm`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["Soul"],
+      transformResponse: (response) => response
+    }),
     getSoulImport: builder.query({
       query: ({ txId, apiUrl, apiKey }) => ({
         url: `${apiUrl}/souls/${txId}`,
@@ -433,6 +445,16 @@ var sdkApi = (0, import_query.createApi)({
       invalidatesTags: ["NPC"],
       transformResponse: (response) => response
     }),
+    postNpcImportConfirm: builder.mutation({
+      query: ({ request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/import/confirm`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["NPC"],
+      transformResponse: (response) => response
+    }),
     // Cortex Remote Endpoint
     postCortexComplete: builder.mutation({
       query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
@@ -452,6 +474,25 @@ var sdkApi = (0, import_query.createApi)({
   })
 });
 
+// src/errors.ts
+var extractThunkErrorMessage = (error, fallback) => {
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    const e = error;
+    if (typeof e.data === "object" && e.data?.message) return String(e.data.message);
+    if (typeof e.data === "string") return e.data;
+    if (e.message) return e.message;
+    if (e.error) return e.error;
+  }
+  return fallback;
+};
+var requireApiKeyGuidance = (apiUrl, apiKey) => {
+  const normalized = apiUrl.toLowerCase();
+  if (normalized.includes("api.forboc.ai") && !apiKey) {
+    throw new Error("Missing API key. Set FORBOCAI_API_KEY (or run `forboc config set apiKey <key>`) for production API calls.");
+  }
+};
+
 // src/bridgeSlice.ts
 var initialState = {
   activePresets: [],
@@ -466,6 +507,7 @@ var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ action, context, npcId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postBridgeValidate.initiate({
         request: { action, context },
         npcId,
@@ -473,8 +515,8 @@ var validateBridgeThunk = (0, import_toolkit.createAsyncThunk)(
         apiKey
       })).unwrap();
       return data;
-    } catch (e) {
-      return rejectWithValue(e.message || "Bridge validation failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Bridge validation failed"));
     }
   }
 );
@@ -483,9 +525,10 @@ var loadBridgePresetThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ presetName, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.postBridgePreset.initiate({ presetName, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to load preset");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to load preset"));
     }
   }
 );
@@ -494,9 +537,10 @@ var getBridgeRulesThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getBridgeRules.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list bridge rules");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list bridge rules"));
     }
   }
 );
@@ -505,9 +549,10 @@ var listRulesetsThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getRulesets.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list rulesets");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rulesets"));
     }
   }
 );
@@ -516,9 +561,10 @@ var listRulePresetsThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getRulePresets.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list rule presets");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list rule presets"));
     }
   }
 );
@@ -527,9 +573,10 @@ var registerRulesetThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ ruleset, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.postRuleRegister.initiate({ request: ruleset, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to register ruleset");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to register ruleset"));
     }
   }
 );
@@ -538,9 +585,10 @@ var deleteRulesetThunk = (0, import_toolkit.createAsyncThunk)(
   async ({ rulesetId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.deleteRule.initiate({ rulesetId, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to delete ruleset");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to delete ruleset"));
     }
   }
 );
@@ -589,6 +637,124 @@ var bridgeSlice_default = bridgeSlice.reducer;
 
 // src/soulSlice.ts
 var import_toolkit2 = require("@reduxjs/toolkit");
+
+// src/handlers/arweave.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var getLocalWalletToken = () => {
+  const maybeEnv = globalThis.process?.env;
+  return maybeEnv?.ARWEAVE_WALLET_JWK ?? null;
+};
+var withTimeout = async (promiseFactory, timeoutMs = 6e4) => {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await promiseFactory(controller.signal);
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+async function handler_ArweaveUpload(instruction, maxRetries = 3) {
+  const headers = {
+    "Content-Type": instruction.auiContentType || "application/json"
+  };
+  const authToken = instruction.auiAuthHeader ?? (getLocalWalletToken() ? `Bearer ${getLocalWalletToken()}` : null);
+  if (authToken) {
+    headers.Authorization = authToken;
+  }
+  let attempt = 0;
+  while (attempt < maxRetries) {
+    attempt += 1;
+    try {
+      const response = await withTimeout(
+        (signal) => fetch(instruction.auiEndpoint, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(instruction.auiPayload),
+          signal
+        })
+      );
+      let responseBody = null;
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = null;
+      }
+      const txId = responseBody?.id ?? `ar_tx_sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const success = response.status >= 200 && response.status < 300;
+      if (!success && attempt < maxRetries) {
+        await sleep(250 * 2 ** (attempt - 1));
+        continue;
+      }
+      return {
+        aurTxId: txId,
+        aurStatus: response.status,
+        aurSuccess: success,
+        aurError: success ? null : `upload_failed_status_${response.status}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (attempt < maxRetries) {
+        await sleep(250 * 2 ** (attempt - 1));
+        continue;
+      }
+      return {
+        aurTxId: `ar_tx_failed_${Date.now()}`,
+        aurStatus: 0,
+        aurSuccess: false,
+        aurError: `upload_request_failed:${message}`
+      };
+    }
+  }
+  return {
+    aurTxId: `ar_tx_failed_${Date.now()}`,
+    aurStatus: 0,
+    aurSuccess: false,
+    aurError: "upload_retry_exhausted"
+  };
+}
+async function handler_ArweaveDownload(instruction) {
+  try {
+    const response = await withTimeout(
+      (signal) => fetch(instruction.adiGatewayUrl, {
+        method: "GET",
+        signal
+      })
+    );
+    if (response.status < 200 || response.status >= 300) {
+      return {
+        adrBody: null,
+        adrStatus: response.status,
+        adrSuccess: false,
+        adrError: `download_failed_status_${response.status}`
+      };
+    }
+    try {
+      const body = await response.json();
+      return {
+        adrBody: body,
+        adrStatus: response.status,
+        adrSuccess: true,
+        adrError: null
+      };
+    } catch {
+      return {
+        adrBody: null,
+        adrStatus: response.status,
+        adrSuccess: false,
+        adrError: "download_invalid_json"
+      };
+    }
+  } catch (error) {
+    return {
+      adrBody: null,
+      adrStatus: 0,
+      adrSuccess: false,
+      adrError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/soulSlice.ts
 var initialState2 = {
   exportStatus: "idle",
   importStatus: "idle",
@@ -599,26 +765,45 @@ var initialState2 = {
 };
 var remoteExportSoulThunk = (0, import_toolkit2.createAsyncThunk)(
   "soul/export",
-  async ({ npcId: argNpcId, apiUrl, apiKey, memories = [] }, { getState, dispatch: dispatch2, rejectWithValue }) => {
+  async ({ npcId: argNpcId, apiUrl, apiKey }, { getState, dispatch: dispatch2, rejectWithValue }) => {
     try {
       const state = getState().npc;
       const npcId = argNpcId || state.activeNpcId;
       const npc = state.entities[npcId];
       if (!npc) throw new Error(`NPC ${npcId} not found`);
       const url = apiUrl || "https://api.forboc.ai";
-      const result = await dispatch2(sdkApi.endpoints.postSoulExport.initiate({
-        npcId,
-        request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
-        apiUrl: url,
-        apiKey
-      })).unwrap();
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        sdkApi.endpoints.postSoulExport.initiate({
+          npcId,
+          request: { npcIdRef: npcId, persona: npc.persona || "NPC", npcState: npc.state },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      const uploadResult = await handler_ArweaveUpload({
+        ...phase1.se1Instruction,
+        auiAuthHeader: phase1.se1Instruction.auiAuthHeader ?? null
+      });
+      const final = await dispatch2(
+        sdkApi.endpoints.postSoulExportConfirm.initiate({
+          npcId,
+          request: {
+            secUploadResult: uploadResult,
+            secSignedPayload: phase1.se1SignedPayload,
+            secSignature: phase1.se1Signature
+          },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
       return {
-        txId: result.txId,
-        url: result.arweaveUrl,
-        soul: result.soul
+        txId: final.txId,
+        url: final.arweaveUrl,
+        soul: final.soul
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Soul export failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul export failed"));
     }
   }
 );
@@ -627,10 +812,31 @@ var importSoulFromArweaveThunk = (0, import_toolkit2.createAsyncThunk)(
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
-      const data = await dispatch2(sdkApi.endpoints.getSoulImport.initiate({ txId, apiUrl: url, apiKey })).unwrap();
-      return data;
-    } catch (e) {
-      return rejectWithValue(e.message || "Soul import failed");
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        sdkApi.endpoints.postNpcImport.initiate({ request: { txIdRef: txId }, apiUrl: url, apiKey })
+      ).unwrap();
+      const downloadResult = await handler_ArweaveDownload(phase1.si1Instruction);
+      const npc = await dispatch2(
+        sdkApi.endpoints.postNpcImportConfirm.initiate({
+          request: {
+            sicTxId: txId,
+            sicDownloadResult: downloadResult
+          },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      return {
+        id: txId,
+        version: "2.0.0",
+        name: npc.npcId,
+        persona: npc.persona,
+        memories: [],
+        state: npc.data || {}
+      };
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul import failed"));
     }
   }
 );
@@ -639,10 +845,11 @@ var getSoulListThunk = (0, import_toolkit2.createAsyncThunk)(
   async ({ limit = 50, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getSouls.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return data.souls || [];
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list souls");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list souls"));
     }
   }
 );
@@ -651,9 +858,10 @@ var verifySoulThunk = (0, import_toolkit2.createAsyncThunk)(
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.postSoulVerify.initiate({ txId, apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Soul verify failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Soul verify failed"));
     }
   }
 );
@@ -662,13 +870,24 @@ var importNpcFromSoulThunk = (0, import_toolkit2.createAsyncThunk)(
   async ({ txId, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
-      return await dispatch2(sdkApi.endpoints.postNpcImport.initiate({
-        request: { txIdRef: txId },
-        apiUrl: url,
-        apiKey
-      })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "NPC import from soul failed");
+      requireApiKeyGuidance(url, apiKey);
+      const phase1 = await dispatch2(
+        sdkApi.endpoints.postNpcImport.initiate({
+          request: { txIdRef: txId },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+      const downloadResult = await handler_ArweaveDownload(phase1.si1Instruction);
+      return await dispatch2(
+        sdkApi.endpoints.postNpcImportConfirm.initiate({
+          request: { sicTxId: txId, sicDownloadResult: downloadResult },
+          apiUrl: url,
+          apiKey
+        })
+      ).unwrap();
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "NPC import from soul failed"));
     }
   }
 );
@@ -727,6 +946,7 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
   async (config, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const apiUrl = config.apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(apiUrl, config.apiKey);
       const data = await dispatch2(sdkApi.endpoints.postGhostRun.initiate({
         request: { testSuite: config.testSuite, duration: config.duration ?? 300 },
         apiUrl,
@@ -736,8 +956,8 @@ var startGhostThunk = (0, import_toolkit3.createAsyncThunk)(
         sessionId: data.sessionId,
         status: data.runStatus
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to start Ghost");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to start Ghost"));
     }
   }
 );
@@ -749,6 +969,7 @@ var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
       const targetSession = sessionId || state.activeSessionId;
       if (!targetSession) throw new Error("No active Ghost session");
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getGhostStatus.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.ghostSessionId,
@@ -758,8 +979,8 @@ var getGhostStatusThunk = (0, import_toolkit3.createAsyncThunk)(
         duration: data.ghostDuration || 0,
         errors: data.ghostErrors
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to get ghost status");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to get ghost status"));
     }
   }
 );
@@ -771,6 +992,7 @@ var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
       const targetSession = sessionId || state.activeSessionId;
       if (!targetSession) throw new Error("No active Ghost session");
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getGhostResults.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         sessionId: data.resultsSessionId,
@@ -789,8 +1011,8 @@ var getGhostResultsThunk = (0, import_toolkit3.createAsyncThunk)(
         coverage: data.resultsCoverage,
         metrics: Object.fromEntries(data.resultsMetrics || [])
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to get ghost results");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to get ghost results"));
     }
   }
 );
@@ -802,14 +1024,15 @@ var stopGhostThunk = (0, import_toolkit3.createAsyncThunk)(
       const targetSession = sessionId || state.activeSessionId;
       if (!targetSession) throw new Error("No active Ghost session");
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postGhostStop.initiate({ sessionId: targetSession, apiUrl: url, apiKey })).unwrap();
       return {
         stopped: data.stopped,
         status: data.stopStatus,
         sessionId: data.stopSessionId
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to stop ghost session");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to stop ghost session"));
     }
   }
 );
@@ -818,6 +1041,7 @@ var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
   async ({ limit = 10, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.getGhostHistory.initiate({ limit, apiUrl: url, apiKey })).unwrap();
       return (data.sessions || []).map((s) => ({
         sessionId: s.sessionId,
@@ -827,8 +1051,8 @@ var getGhostHistoryThunk = (0, import_toolkit3.createAsyncThunk)(
         status: s.status,
         passRate: s.passRate
       }));
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to get ghost history");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to get ghost history"));
     }
   }
 );
@@ -863,7 +1087,7 @@ var ghostSlice = (0, import_toolkit3.createSlice)({
       state.status = "completed";
     }).addCase(stopGhostThunk.fulfilled, (state, action) => {
       if (action.payload.stopped) {
-        state.status = "failed";
+        state.status = "completed";
       } else {
         state.error = action.payload.status || "Ghost stop request did not stop a session";
       }
@@ -959,7 +1183,8 @@ var npcSlice = (0, import_toolkit4.createSlice)({
         persona,
         state: initialState5 || {},
         history: [],
-        isBlocked: false
+        isBlocked: false,
+        stateLog: [{ timestamp: Date.now(), delta: initialState5 || {}, state: initialState5 || {} }]
       });
       state.activeNpcId = id;
     },
@@ -974,7 +1199,9 @@ var npcSlice = (0, import_toolkit4.createSlice)({
       const { id, delta } = action.payload;
       const npc = state.entities[id];
       if (npc) {
-        npc.state = { ...npc.state, ...delta };
+        const newState = { ...npc.state, ...delta };
+        npc.state = newState;
+        npc.stateLog.push({ timestamp: Date.now(), delta, state: newState });
       }
     },
     addToHistory: (state, action) => {
@@ -1044,6 +1271,7 @@ var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
   async ({ model = "api-integrated", authKey, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postCortexInit.initiate({
         request: { requestedModel: model, authKey },
         apiUrl: url,
@@ -1055,8 +1283,8 @@ var initRemoteCortexThunk = (0, import_toolkit5.createAsyncThunk)(
         ready: data.state?.toLowerCase() === "ready",
         engine: "remote"
       };
-    } catch (e) {
-      return rejectWithValue(e.message || "Remote cortex init failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Remote cortex init failed"));
     }
   }
 );
@@ -1065,9 +1293,10 @@ var listCortexModelsThunk = (0, import_toolkit5.createAsyncThunk)(
   async ({ apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
       const url = apiUrl || "https://api.forboc.ai";
+      requireApiKeyGuidance(url, apiKey);
       return await dispatch2(sdkApi.endpoints.getCortexModels.initiate({ apiUrl: url, apiKey })).unwrap();
-    } catch (e) {
-      return rejectWithValue(e.message || "Failed to list cortex models");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Failed to list cortex models"));
     }
   }
 );
@@ -1075,6 +1304,7 @@ var completeRemoteThunk = (0, import_toolkit5.createAsyncThunk)(
   "cortex/completeRemote",
   async ({ cortexId, prompt, options, apiUrl, apiKey }, { dispatch: dispatch2, rejectWithValue }) => {
     try {
+      requireApiKeyGuidance(apiUrl, apiKey);
       const data = await dispatch2(sdkApi.endpoints.postCortexComplete.initiate({
         cortexId,
         prompt,
@@ -1083,8 +1313,8 @@ var completeRemoteThunk = (0, import_toolkit5.createAsyncThunk)(
         apiKey
       })).unwrap();
       return data.text;
-    } catch (e) {
-      return rejectWithValue(e.message || "Remote completing failed");
+    } catch (error) {
+      return rejectWithValue(extractThunkErrorMessage(error, "Remote completing failed"));
     }
   }
 );
@@ -1319,7 +1549,7 @@ var dispatch = store.dispatch;
 
 // src/thunks.ts
 var import_toolkit10 = require("@reduxjs/toolkit");
-var extractThunkErrorMessage = (e) => {
+var extractThunkErrorMessage2 = (e) => {
   if (typeof e === "string") return e;
   if (e?.data?.message) return String(e.data.message);
   if (e?.error) return String(e.error);
@@ -1453,7 +1683,7 @@ var processNPC = (0, import_toolkit10.createAsyncThunk)(
       };
       return runProtocolRecursively(initialTape, void 0, 0);
     } catch (e) {
-      const message = extractThunkErrorMessage(e);
+      const message = extractThunkErrorMessage2(e);
       dispatch2(directiveRunFailed({ id: directiveId, error: String(message) }));
       return rejectWithValue(String(message));
     }
@@ -1574,6 +1804,8 @@ var clearMemoryRemoteThunk = (0, import_toolkit10.createAsyncThunk)(
   getGhostStatusThunk,
   getSoulListThunk,
   ghostSlice,
+  handler_ArweaveDownload,
+  handler_ArweaveUpload,
   importNpcFromSoulThunk,
   importSoulFromArweaveThunk,
   initRemoteCortexThunk,