@forbocai/core 0.5.8 → 0.6.0

package/dist/chunk-EBFSO6HV.mjs

@@ -0,0 +1,405 @@
+// src/store.ts
+import { configureStore } from "@reduxjs/toolkit";
+
+// src/apiSlice.ts
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query";
+var sdkApi = createApi({
+  reducerPath: "forbocApi",
+  baseQuery: fetchBaseQuery({
+    baseUrl: "/",
+    prepareHeaders: (headers, { getState }) => {
+      return headers;
+    }
+  }),
+  tagTypes: ["NPC", "Memory", "Cortex", "Ghost", "Soul", "Bridge"],
+  endpoints: (builder) => ({
+    // NPC Endpoints
+    postDirective: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/directive`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["NPC"]
+    }),
+    postContext: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/context`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      })
+    }),
+    postVerdict: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/verdict`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["NPC"]
+    }),
+    postSpeak: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/speak`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      }),
+      invalidatesTags: ["NPC"]
+    }),
+    postDialogue: builder.mutation({
+      query: ({ npcId, request, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/npcs/${npcId}/dialogue`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: request
+      })
+    }),
+    // Ghost Endpoints
+    postGhostRun: builder.mutation({
+      query: ({ request, apiUrl }) => ({ url: `${apiUrl}/ghost/run`, method: "POST", body: request }),
+      invalidatesTags: ["Ghost"]
+    }),
+    getGhostStatus: builder.query({
+      query: ({ sessionId, apiUrl }) => ({ url: `${apiUrl}/ghost/${sessionId}/status`, method: "GET" }),
+      providesTags: ["Ghost"]
+    }),
+    getGhostResults: builder.query({
+      query: ({ sessionId, apiUrl }) => ({ url: `${apiUrl}/ghost/${sessionId}/results`, method: "GET" })
+    }),
+    postGhostStop: builder.mutation({
+      query: ({ sessionId, apiUrl }) => ({ url: `${apiUrl}/ghost/${sessionId}/stop`, method: "POST" }),
+      invalidatesTags: ["Ghost"]
+    }),
+    getGhostHistory: builder.query({
+      query: ({ limit, apiUrl }) => ({ url: `${apiUrl}/ghost/history?limit=${limit}`, method: "GET" }),
+      providesTags: ["Ghost"]
+    }),
+    // Soul Endpoints
+    postSoulExport: builder.mutation({
+      query: ({ npcId, request, apiUrl }) => ({ url: `${apiUrl}/npcs/${npcId}/soul/export`, method: "POST", body: request }),
+      invalidatesTags: ["Soul"]
+    }),
+    getSoulImport: builder.query({
+      query: ({ txId, apiUrl }) => ({ url: `${apiUrl}/souls/${txId}`, method: "GET" })
+    }),
+    getSouls: builder.query({
+      query: ({ limit, apiUrl }) => ({ url: `${apiUrl}/souls?limit=${limit}`, method: "GET" }),
+      providesTags: ["Soul"]
+    }),
+    // Bridge Endpoints
+    postBridgeValidate: builder.mutation({
+      query: ({ request, npcId, apiUrl }) => ({
+        url: npcId ? `${apiUrl}/bridge/validate/${npcId}` : `${apiUrl}/bridge/validate`,
+        method: "POST",
+        body: request
+      })
+    }),
+    getBridgeRules: builder.query({
+      query: ({ apiUrl }) => ({ url: `${apiUrl}/rules`, method: "GET" }),
+      providesTags: ["Bridge"]
+    }),
+    postBridgePreset: builder.mutation({
+      query: ({ presetName, apiUrl }) => ({ url: `${apiUrl}/rules/presets/${presetName}`, method: "POST" }),
+      invalidatesTags: ["Bridge"]
+    }),
+    // Cortex Remote Endpoint
+    postCortexComplete: builder.mutation({
+      query: ({ cortexId, prompt, options, apiUrl, apiKey }) => ({
+        url: `${apiUrl}/cortex/${cortexId}/complete`,
+        method: "POST",
+        headers: apiKey ? { "Authorization": `Bearer ${apiKey}` } : {},
+        body: { prompt, ...options }
+      })
+    })
+  })
+});
+
+// src/npcSlice.ts
+import { createSlice } from "@reduxjs/toolkit";
+var initialState = {
+  id: "",
+  persona: "",
+  state: {},
+  history: [],
+  isBlocked: false
+};
+var npcSlice = createSlice({
+  name: "npc",
+  initialState,
+  reducers: {
+    setNPCInfo: (state, action) => {
+      state.id = action.payload.id;
+      state.persona = action.payload.persona;
+      if (action.payload.initialState) {
+        state.state = action.payload.initialState;
+      }
+    },
+    setNPCState: (state, action) => {
+      state.state = action.payload;
+    },
+    updateNPCState: (state, action) => {
+      state.state = { ...state.state, ...action.payload };
+    },
+    addToHistory: (state, action) => {
+      state.history.push(action.payload);
+    },
+    setHistory: (state, action) => {
+      state.history = action.payload;
+    },
+    setLastAction: (state, action) => {
+      state.lastAction = action.payload;
+    },
+    blockAction: (state, action) => {
+      state.isBlocked = true;
+      state.blockReason = action.payload;
+    },
+    clearBlock: (state) => {
+      state.isBlocked = false;
+      state.blockReason = void 0;
+    }
+  }
+});
+var {
+  setNPCInfo,
+  setNPCState,
+  updateNPCState,
+  addToHistory,
+  setHistory,
+  setLastAction,
+  blockAction,
+  clearBlock
+} = npcSlice.actions;
+var npcSlice_default = npcSlice.reducer;
+
+// src/cortexSlice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {
+  status: {
+    id: "init",
+    model: "none",
+    ready: false,
+    engine: "mock"
+  },
+  isInitializing: false
+};
+var cortexSlice = createSlice2({
+  name: "cortex",
+  initialState: initialState2,
+  reducers: {
+    cortexInitStart: (state) => {
+      state.isInitializing = true;
+      state.error = void 0;
+    },
+    cortexInitSuccess: (state, action) => {
+      state.status = action.payload;
+      state.isInitializing = false;
+      state.error = void 0;
+    },
+    cortexInitFailed: (state, action) => {
+      state.isInitializing = false;
+      state.error = action.payload;
+    },
+    setCortexStatus: (state, action) => {
+      state.status = action.payload;
+    }
+  }
+});
+var {
+  cortexInitStart,
+  cortexInitSuccess,
+  cortexInitFailed,
+  setCortexStatus
+} = cortexSlice.actions;
+var cortexSlice_default = cortexSlice.reducer;
+
+// src/memorySlice.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {
+  trackedItemsCount: 0,
+  lastStoredItem: null,
+  lastRecalledItems: [],
+  storageStatus: "idle",
+  recallStatus: "idle",
+  error: null
+};
+var memorySlice = createSlice3({
+  name: "memory",
+  initialState: initialState3,
+  reducers: {
+    memoryStoreStart: (state) => {
+      state.storageStatus = "storing";
+      state.error = null;
+    },
+    memoryStoreSuccess: (state, action) => {
+      state.storageStatus = "idle";
+      state.lastStoredItem = action.payload;
+      state.trackedItemsCount += 1;
+    },
+    memoryStoreFailed: (state, action) => {
+      state.storageStatus = "error";
+      state.error = action.payload;
+    },
+    memoryRecallStart: (state) => {
+      state.recallStatus = "recalling";
+      state.error = null;
+    },
+    memoryRecallSuccess: (state, action) => {
+      state.recallStatus = "idle";
+      state.lastRecalledItems = action.payload;
+    },
+    memoryRecallFailed: (state, action) => {
+      state.recallStatus = "error";
+      state.error = action.payload;
+    },
+    memoryClear: (state) => {
+      state.trackedItemsCount = 0;
+      state.lastStoredItem = null;
+      state.lastRecalledItems = [];
+    }
+  }
+});
+var {
+  memoryStoreStart,
+  memoryStoreSuccess,
+  memoryStoreFailed,
+  memoryRecallStart,
+  memoryRecallSuccess,
+  memoryRecallFailed,
+  memoryClear
+} = memorySlice.actions;
+var memorySlice_default = memorySlice.reducer;
+
+// src/store.ts
+var createSDKStore = () => {
+  return configureStore({
+    reducer: {
+      [sdkApi.reducerPath]: sdkApi.reducer,
+      npc: npcSlice_default,
+      cortex: cortexSlice_default,
+      memory: memorySlice_default
+    },
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(sdkApi.middleware)
+  });
+};
+var store = createSDKStore();
+var dispatch = store.dispatch;
+
+// src/soul.ts
+var createSoul = (id, name, persona, state, memories = []) => ({
+  id,
+  version: "1.0.0",
+  name,
+  persona,
+  state: { ...state },
+  memories: [...memories]
+});
+var serializeSoul = (soul) => JSON.stringify(soul, null, 2);
+var deserializeSoul = (json) => {
+  const parsed = JSON.parse(json);
+  if (!parsed.id || !parsed.persona || !parsed.state) {
+    throw new Error("Invalid Soul format: missing required fields");
+  }
+  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
+  };
+};
+var exportSoul = async (npcId, _soul, config = {}) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  try {
+    const data = await dispatch(sdkApi.endpoints.postSoulExport.initiate({
+      npcId,
+      request: {
+        agentIdRef: npcId,
+        persona: _soul.persona,
+        npcState: _soul.state
+      },
+      apiUrl
+    })).unwrap();
+    return {
+      txId: data.txId,
+      url: data.url,
+      soul: _soul
+      // Return the local soul data as context
+    };
+  } catch (e) {
+    throw new Error(`Soul export failed: ${e.message || "Network error"}`);
+  }
+};
+var importSoulFromArweave = async (txId, config = {}) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  try {
+    const data = await dispatch(sdkApi.endpoints.getSoulImport.initiate({ txId, apiUrl })).unwrap();
+    return data;
+  } catch (e) {
+    throw new Error(`Import failed: ${e.message || "Network error"}`);
+  }
+};
+var getSoulList = async (limit = 50, apiUrl = "https://api.forboc.ai") => {
+  try {
+    const data = await dispatch(sdkApi.endpoints.getSouls.initiate({ limit, apiUrl })).unwrap();
+    return data.souls || [];
+  } catch {
+    return [];
+  }
+};
+var createSoulInstance = (id, name, persona, state, memories = []) => {
+  const soulData = createSoul(id, name, persona, state, memories);
+  return {
+    export: (config) => exportSoul(id, soulData, config),
+    toJSON: () => ({ ...soulData })
+  };
+};
+var validateSoul = (soul) => {
+  const errors = [
+    !soul.id && "Missing id",
+    !soul.persona && "Missing persona",
+    !soul.state && "Missing state"
+  ].filter((e) => !!e);
+  return { valid: errors.length === 0, errors };
+};
+
+export {
+  sdkApi,
+  npcSlice,
+  setNPCInfo,
+  setNPCState,
+  updateNPCState,
+  addToHistory,
+  setHistory,
+  setLastAction,
+  blockAction,
+  clearBlock,
+  cortexSlice,
+  cortexInitStart,
+  cortexInitSuccess,
+  cortexInitFailed,
+  setCortexStatus,
+  memorySlice,
+  memoryStoreStart,
+  memoryStoreSuccess,
+  memoryStoreFailed,
+  memoryRecallStart,
+  memoryRecallSuccess,
+  memoryRecallFailed,
+  memoryClear,
+  createSDKStore,
+  store,
+  dispatch,
+  createSoul,
+  serializeSoul,
+  deserializeSoul,
+  exportSoul,
+  importSoulFromArweave,
+  getSoulList,
+  createSoulInstance,
+  validateSoul
+};

package/dist/chunk-ZO4M6UZR.mjs

@@ -0,0 +1,86 @@
+// src/soul.ts
+var createSoul = (id, name, persona, state, memories = []) => ({
+  id,
+  version: "1.0.0",
+  name,
+  persona,
+  state: { ...state },
+  memories: [...memories]
+});
+var serializeSoul = (soul) => JSON.stringify(soul, null, 2);
+var deserializeSoul = (json) => {
+  const parsed = JSON.parse(json);
+  if (!parsed.id || !parsed.persona || !parsed.state) {
+    throw new Error("Invalid Soul format: missing required fields");
+  }
+  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
+  };
+};
+var exportSoul = async (npcId, _soul, config = {}) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const response = await fetch(`${apiUrl}/npcs/${npcId}/soul/export`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      agentIdRef: npcId,
+      persona: _soul.persona,
+      npcState: _soul.state
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Soul export failed: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return {
+    txId: data.txId,
+    url: data.url,
+    soul: _soul
+    // Return the local soul data as context
+  };
+};
+var importSoulFromArweave = async (txId, config = {}) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const response = await fetch(`${apiUrl}/souls/${txId}`);
+  if (!response.ok) throw new Error(`Import failed: ${response.statusText}`);
+  const data = await response.json();
+  return data;
+};
+var getSoulList = async (limit = 50, apiUrl = "https://api.forboc.ai") => {
+  const response = await fetch(`${apiUrl}/souls?limit=${limit}`);
+  if (!response.ok) return [];
+  const data = await response.json();
+  return data.souls || [];
+};
+var createSoulInstance = (id, name, persona, state, memories = []) => {
+  const soulData = createSoul(id, name, persona, state, memories);
+  return {
+    export: (config) => exportSoul(id, soulData, config),
+    toJSON: () => ({ ...soulData })
+  };
+};
+var validateSoul = (soul) => {
+  const errors = [
+    !soul.id && "Missing id",
+    !soul.persona && "Missing persona",
+    !soul.state && "Missing state"
+  ].filter((e) => !!e);
+  return { valid: errors.length === 0, errors };
+};
+
+export {
+  createSoul,
+  serializeSoul,
+  deserializeSoul,
+  exportSoul,
+  importSoulFromArweave,
+  getSoulList,
+  createSoulInstance,
+  validateSoul
+};