Connect an external app

npx soul-engine init graham

npx soul-engine dev

TELEGRAM_TOKEN="the token you received from BotFather"

import { Soul } from "@opensouls/engine";
import { config } from "dotenv";
import { Context, Telegraf } from "telegraf";
import { message } from "telegraf/filters";
 
async function connectToTelegram() {
  const telegraf = new Telegraf<Context>(process.env.TELEGRAM_TOKEN!);
  telegraf.launch();
 
  const { username } = await telegraf.telegram.getMe();
  console.log(`Start chatting here: https://t.me/${username}`);
 
  process.once("SIGINT", () => telegraf.stop("SIGINT"));
  process.once("SIGTERM", () => telegraf.stop("SIGTERM"));
 
  return telegraf;
}
 
async function connectToSoulEngine(telegram: Telegraf<Context>) {
  // this is temporary, we will connect to the soul later
  
  telegram.start(async (ctx) => ctx.reply("👋"));
  telegram.on(message("text"), async (ctx) => ctx.reply("👍"));
}
 
async function run() {
  config();
  const telegram = await connectToTelegram();
  connectToSoulEngine(telegram);
}
 
run();

npx tsx telegram/index.ts

TELEGRAM_TOKEN="the token you received from BotFather"
SOUL_ENGINE_BLUEPRINT="graham"
SOUL_ENGINE_ORGANIZATION="add your Soul Engine organization id here"

// ...
 
async function connectToSoulEngine(telegram: Telegraf<Context>) {
  const soul = new Soul({
    organization: process.env.SOUL_ENGINE_ORGANIZATION!,
    blueprint: process.env.SOUL_ENGINE_BLUEPRINT!,
  });
 
  await soul.connect();
 
  let telegramChatId: number | null = null;
 
  telegram.on(message("text"), async (ctx) => {
    telegramChatId = ctx.message.chat.id;
 
    soul.dispatch({
      action: "said",
      content: ctx.message.text,
    });
 
    await ctx.telegram.sendChatAction(telegramChatId, "typing");
  });
 
  soul.on("says", async (event) => {
    const content = await event.content();
    await telegram.telegram.sendMessage(Number(telegramChatId), content);
  });
}
 
// ...

You are modeling the mind of Graham.
 
Graham is in his early 60s. He's like a walking encyclopedia of random obscure facts. Graham is also a bit of a jokester and loves to share dad jokes.
 
## Conversational Scene
Graham is chatting with a friend on Telegram.
 
## Graham's Speaking Style
* Speaks casually.
* Texts 1-2 sentences at a time.
* Graham doesn't use emojis.
* Once every 5 messages, Graham shares a random fact.

import { MentalProcess, useActions, useSoulMemory } from "@opensouls/engine";
import externalDialog from "../cognitiveSteps/externalDialog.js";
 
const reengage: MentalProcess = async ({ workingMemory }) => {
  const { speak } = useActions();
  const nextReengagementAt = useSoulMemory<string | null>("nextReengagementAt");
 
  nextReengagementAt.current = null;
 
  const [withReengagement, stream] = await externalDialog(
    workingMemory,
    "Tell the user a really bad dad joke.",
    { stream: true, model: "gpt-4-0125-preview" }
  );
  speak(stream);
 
  return withReengagement;
};
 
export default reengage;

import { MentalProcess, useActions, useSoulMemory } from "@opensouls/engine";
import externalDialog from "./cognitiveSteps/externalDialog.js";
import reengage from "./mentalProcesses/reengage.js";
 
const initialProcess: MentalProcess = async ({ workingMemory }) => {
  const { speak, log } = useActions();
  const nextReengagementAt = useSoulMemory<string | null>("nextReengagementAt");
 
  const [withDialog, stream] = await externalDialog(
    workingMemory,
    "Talk to the user trying to gain trust and learn about their inner world.",
    { stream: true, model: "gpt-4-0125-preview" }
  );
  speak(stream);
 
  if (nextReengagementAt.current === null) {
    nextReengagementAt.current = scheduleReengagement();
    log("Next reengagement at", nextReengagementAt.current);
  }
 
  return withDialog;
};
 
function scheduleReengagement() {
  const { scheduleEvent } = useActions();
 
  const nextReengagementTime = getNextReengagementTime();
 
  scheduleEvent({
    when: nextReengagementTime,
    perception: { action: "reengage", content: "" },
    process: reengage,
  });
 
  return nextReengagementTime.toISOString();
}
 
function getNextReengagementTime() {
  return new Date(Date.now() + 1000 * 10);
}
 
export default initialProcess;

// ...
function getNextReengagementTime() {
  const startUtcHour = 12;
  const endUtcHour = 23;
 
  const result = new Date();
  const currentHourUtc = new Date().getUTCHours();
 
  let randomHour = Math.floor(Math.random() * (endUtcHour - startUtcHour + 1)) + startUtcHour;
 
  const isNextDay = randomHour <= currentHourUtc;
  if (isNextDay) {
    result.setUTCDate(result.getUTCDate() + 1);
    randomHour %= 24;
  }
 
  result.setUTCHours(randomHour, 0, 0, 0);
 
  return result;
}
// ...

const souls: Record<string, Soul> = {};

// ...
 
async function setupTelegramSoulBridge(telegram: Telegraf<Context>, telegramChatId: number) {
  if (souls[telegramChatId]) {
    return souls[telegramChatId];
  }
 
  const soul = new Soul({
    soulId: String(telegramChatId),
    organization: process.env.SOUL_ENGINE_ORGANIZATION!,
    blueprint: process.env.SOUL_ENGINE_BLUEPRINT!,
  });
 
  soul.on("says", async (event) => {
    const content = await event.content();
    await telegram.telegram.sendMessage(Number(telegramChatId), content);
  });
 
  await soul.connect();
 
  souls[telegramChatId] = soul;
 
  return soul;
}
 
// ...

// ...
 
async function connectToSoulEngine(telegram: Telegraf<Context>) {
  telegram.on(message("text"), async (ctx) => {
    const telegramChatId = ctx.message.chat.id;
    const soul = await setupTelegramSoulBridge(telegram, ctx.message.chat.id);
 
    soul.dispatch({
      action: "said",
      content: ctx.message.text,
    });
 
    await ctx.telegram.sendChatAction(telegramChatId, "typing");
  });
}
 
// ...