solanapolis 1.0.0

package/convex/_generated/server.js

@@ -0,0 +1,93 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;

package/convex/agent/conversation.ts

@@ -0,0 +1,352 @@
+import { v } from 'convex/values';
+import { Id } from '../_generated/dataModel';
+import { ActionCtx, internalQuery } from '../_generated/server';
+import { LLMMessage, chatCompletion } from '../util/llm';
+import * as memory from './memory';
+import { api, internal } from '../_generated/api';
+import * as embeddingsCache from './embeddingsCache';
+import { GameId, conversationId, playerId } from '../aiTown/ids';
+import { NUM_MEMORIES_TO_SEARCH } from '../constants';
+
+const selfInternal = internal.agent.conversation;
+
+export async function startConversationMessage(
+  ctx: ActionCtx,
+  worldId: Id<'worlds'>,
+  conversationId: GameId<'conversations'>,
+  playerId: GameId<'players'>,
+  otherPlayerId: GameId<'players'>,
+): Promise<string> {
+  const { player, otherPlayer, agent, otherAgent, lastConversation } = await ctx.runQuery(
+    selfInternal.queryPromptData,
+    {
+      worldId,
+      playerId,
+      otherPlayerId,
+      conversationId,
+    },
+  );
+  const embedding = await embeddingsCache.fetch(
+    ctx,
+    `${player.name} is talking to ${otherPlayer.name}`,
+  );
+
+  const memories = await memory.searchMemories(
+    ctx,
+    player.id as GameId<'players'>,
+    embedding,
+    Number(process.env.NUM_MEMORIES_TO_SEARCH) || NUM_MEMORIES_TO_SEARCH,
+  );
+
+  const memoryWithOtherPlayer = memories.find(
+    (m) => m.data.type === 'conversation' && m.data.playerIds.includes(otherPlayerId),
+  );
+  const prompt = [
+    `You are ${player.name}, and you just started a conversation with ${otherPlayer.name}.`,
+  ];
+  prompt.push(...agentPrompts(otherPlayer, agent, otherAgent ?? null));
+  prompt.push(...previousConversationPrompt(otherPlayer, lastConversation));
+  prompt.push(...relatedMemoriesPrompt(memories));
+  if (memoryWithOtherPlayer) {
+    prompt.push(
+      `Be sure to include some detail or question about a previous conversation in your greeting.`,
+    );
+  }
+  const lastPrompt = `${player.name} to ${otherPlayer.name}:`;
+  prompt.push(lastPrompt);
+
+  const { content } = await chatCompletion({
+    messages: [
+      {
+        role: 'system',
+        content: prompt.join('\n'),
+      },
+    ],
+    max_tokens: 300,
+    stop: stopWords(otherPlayer.name, player.name),
+  });
+  return trimContentPrefx(content, lastPrompt);
+}
+
+function trimContentPrefx(content: string, prompt: string) {
+  if (content.startsWith(prompt)) {
+    return content.slice(prompt.length).trim();
+  }
+  return content;
+}
+
+export async function continueConversationMessage(
+  ctx: ActionCtx,
+  worldId: Id<'worlds'>,
+  conversationId: GameId<'conversations'>,
+  playerId: GameId<'players'>,
+  otherPlayerId: GameId<'players'>,
+): Promise<string> {
+  const { player, otherPlayer, conversation, agent, otherAgent } = await ctx.runQuery(
+    selfInternal.queryPromptData,
+    {
+      worldId,
+      playerId,
+      otherPlayerId,
+      conversationId,
+    },
+  );
+  const now = Date.now();
+  const started = new Date(conversation.created);
+  const embedding = await embeddingsCache.fetch(
+    ctx,
+    `What do you think about ${otherPlayer.name}?`,
+  );
+  const memories = await memory.searchMemories(ctx, player.id as GameId<'players'>, embedding, 3);
+  const prompt = [
+    `You are ${player.name}, and you're currently in a conversation with ${otherPlayer.name}.`,
+    `The conversation started at ${started.toLocaleString()}. It's now ${now.toLocaleString()}.`,
+  ];
+  prompt.push(...agentPrompts(otherPlayer, agent, otherAgent ?? null));
+  prompt.push(...relatedMemoriesPrompt(memories));
+  prompt.push(
+    `Below is the current chat history between you and ${otherPlayer.name}.`,
+    `DO NOT greet them again. Do NOT use the word "Hey" too often. Your response should be brief and within 200 characters.`,
+  );
+
+  const llmMessages: LLMMessage[] = [
+    {
+      role: 'system',
+      content: prompt.join('\n'),
+    },
+    ...(await previousMessages(
+      ctx,
+      worldId,
+      player,
+      otherPlayer,
+      conversation.id as GameId<'conversations'>,
+    )),
+  ];
+  const lastPrompt = `${player.name} to ${otherPlayer.name}:`;
+  llmMessages.push({ role: 'user', content: lastPrompt });
+
+  const { content } = await chatCompletion({
+    messages: llmMessages,
+    max_tokens: 300,
+    stop: stopWords(otherPlayer.name, player.name),
+  });
+  return trimContentPrefx(content, lastPrompt);
+}
+
+export async function leaveConversationMessage(
+  ctx: ActionCtx,
+  worldId: Id<'worlds'>,
+  conversationId: GameId<'conversations'>,
+  playerId: GameId<'players'>,
+  otherPlayerId: GameId<'players'>,
+): Promise<string> {
+  const { player, otherPlayer, conversation, agent, otherAgent } = await ctx.runQuery(
+    selfInternal.queryPromptData,
+    {
+      worldId,
+      playerId,
+      otherPlayerId,
+      conversationId,
+    },
+  );
+  const prompt = [
+    `You are ${player.name}, and you're currently in a conversation with ${otherPlayer.name}.`,
+    `You've decided to leave the question and would like to politely tell them you're leaving the conversation.`,
+  ];
+  prompt.push(...agentPrompts(otherPlayer, agent, otherAgent ?? null));
+  prompt.push(
+    `Below is the current chat history between you and ${otherPlayer.name}.`,
+    `How would you like to tell them that you're leaving? Your response should be brief and within 200 characters.`,
+  );
+  const llmMessages: LLMMessage[] = [
+    {
+      role: 'system',
+      content: prompt.join('\n'),
+    },
+    ...(await previousMessages(
+      ctx,
+      worldId,
+      player,
+      otherPlayer,
+      conversation.id as GameId<'conversations'>,
+    )),
+  ];
+  const lastPrompt = `${player.name} to ${otherPlayer.name}:`;
+  llmMessages.push({ role: 'user', content: lastPrompt });
+
+  const { content } = await chatCompletion({
+    messages: llmMessages,
+    max_tokens: 300,
+    stop: stopWords(otherPlayer.name, player.name),
+  });
+  return trimContentPrefx(content, lastPrompt);
+}
+
+function agentPrompts(
+  otherPlayer: { name: string },
+  agent: { identity: string; plan: string } | null,
+  otherAgent: { identity: string; plan: string } | null,
+): string[] {
+  const prompt = [];
+  if (agent) {
+    prompt.push(`About you: ${agent.identity}`);
+    prompt.push(`Your goals for the conversation: ${agent.plan}`);
+  }
+  if (otherAgent) {
+    prompt.push(`About ${otherPlayer.name}: ${otherAgent.identity}`);
+  }
+  return prompt;
+}
+
+function previousConversationPrompt(
+  otherPlayer: { name: string },
+  conversation: { created: number } | null,
+): string[] {
+  const prompt = [];
+  if (conversation) {
+    const prev = new Date(conversation.created);
+    const now = new Date();
+    prompt.push(
+      `Last time you chatted with ${
+        otherPlayer.name
+      } it was ${prev.toLocaleString()}. It's now ${now.toLocaleString()}.`,
+    );
+  }
+  return prompt;
+}
+
+function relatedMemoriesPrompt(memories: memory.Memory[]): string[] {
+  const prompt = [];
+  if (memories.length > 0) {
+    prompt.push(`Here are some related memories in decreasing relevance order:`);
+    for (const memory of memories) {
+      prompt.push(' - ' + memory.description);
+    }
+  }
+  return prompt;
+}
+
+async function previousMessages(
+  ctx: ActionCtx,
+  worldId: Id<'worlds'>,
+  player: { id: string; name: string },
+  otherPlayer: { id: string; name: string },
+  conversationId: GameId<'conversations'>,
+) {
+  const llmMessages: LLMMessage[] = [];
+  const prevMessages = await ctx.runQuery(api.messages.listMessages, { worldId, conversationId });
+  for (const message of prevMessages) {
+    const author = message.author === player.id ? player : otherPlayer;
+    const recipient = message.author === player.id ? otherPlayer : player;
+    llmMessages.push({
+      role: 'user',
+      content: `${author.name} to ${recipient.name}: ${message.text}`,
+    });
+  }
+  return llmMessages;
+}
+
+export const queryPromptData = internalQuery({
+  args: {
+    worldId: v.id('worlds'),
+    playerId,
+    otherPlayerId: playerId,
+    conversationId,
+  },
+  handler: async (ctx, args) => {
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new Error(`World ${args.worldId} not found`);
+    }
+    const player = world.players.find((p) => p.id === args.playerId);
+    if (!player) {
+      throw new Error(`Player ${args.playerId} not found`);
+    }
+    const playerDescription = await ctx.db
+      .query('playerDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId).eq('playerId', args.playerId))
+      .first();
+    if (!playerDescription) {
+      throw new Error(`Player description for ${args.playerId} not found`);
+    }
+    const otherPlayer = world.players.find((p) => p.id === args.otherPlayerId);
+    if (!otherPlayer) {
+      throw new Error(`Player ${args.otherPlayerId} not found`);
+    }
+    const otherPlayerDescription = await ctx.db
+      .query('playerDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId).eq('playerId', args.otherPlayerId))
+      .first();
+    if (!otherPlayerDescription) {
+      throw new Error(`Player description for ${args.otherPlayerId} not found`);
+    }
+    const conversation = world.conversations.find((c) => c.id === args.conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation ${args.conversationId} not found`);
+    }
+    const agent = world.agents.find((a) => a.playerId === args.playerId);
+    if (!agent) {
+      throw new Error(`Player ${args.playerId} not found`);
+    }
+    const agentDescription = await ctx.db
+      .query('agentDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId).eq('agentId', agent.id))
+      .first();
+    if (!agentDescription) {
+      throw new Error(`Agent description for ${agent.id} not found`);
+    }
+    const otherAgent = world.agents.find((a) => a.playerId === args.otherPlayerId);
+    let otherAgentDescription;
+    if (otherAgent) {
+      otherAgentDescription = await ctx.db
+        .query('agentDescriptions')
+        .withIndex('worldId', (q) => q.eq('worldId', args.worldId).eq('agentId', otherAgent.id))
+        .first();
+      if (!otherAgentDescription) {
+        throw new Error(`Agent description for ${otherAgent.id} not found`);
+      }
+    }
+    const lastTogether = await ctx.db
+      .query('participatedTogether')
+      .withIndex('edge', (q) =>
+        q
+          .eq('worldId', args.worldId)
+          .eq('player1', args.playerId)
+          .eq('player2', args.otherPlayerId),
+      )
+      // Order by conversation end time descending.
+      .order('desc')
+      .first();
+
+    let lastConversation = null;
+    if (lastTogether) {
+      lastConversation = await ctx.db
+        .query('archivedConversations')
+        .withIndex('worldId', (q) =>
+          q.eq('worldId', args.worldId).eq('id', lastTogether.conversationId),
+        )
+        .first();
+      if (!lastConversation) {
+        throw new Error(`Conversation ${lastTogether.conversationId} not found`);
+      }
+    }
+    return {
+      player: { name: playerDescription.name, ...player },
+      otherPlayer: { name: otherPlayerDescription.name, ...otherPlayer },
+      conversation,
+      agent: { identity: agentDescription.identity, plan: agentDescription.plan, ...agent },
+      otherAgent: otherAgent && {
+        identity: otherAgentDescription!.identity,
+        plan: otherAgentDescription!.plan,
+        ...otherAgent,
+      },
+      lastConversation,
+    };
+  },
+});
+
+function stopWords(otherPlayer: string, player: string) {
+  // These are the words we ask the LLM to stop on. OpenAI only supports 4.
+  const variants = [`${otherPlayer} to ${player}`];
+  return variants.flatMap((stop) => [stop + ':', stop.toLowerCase() + ':']);
+}

package/convex/agent/embeddingsCache.ts

@@ -0,0 +1,110 @@
+import { v } from 'convex/values';
+import { ActionCtx, internalMutation, internalQuery } from '../_generated/server';
+import { internal } from '../_generated/api';
+import { Id } from '../_generated/dataModel';
+import { fetchEmbeddingBatch } from '../util/llm';
+
+const selfInternal = internal.agent.embeddingsCache;
+
+export async function fetch(ctx: ActionCtx, text: string) {
+  const result = await fetchBatch(ctx, [text]);
+  return result.embeddings[0];
+}
+
+export async function fetchBatch(ctx: ActionCtx, texts: string[]) {
+  const start = Date.now();
+
+  const textHashes = await Promise.all(texts.map((text) => hashText(text)));
+  const results = new Array<number[]>(texts.length);
+  const cacheResults = await ctx.runQuery(selfInternal.getEmbeddingsByText, {
+    textHashes,
+  });
+  for (const { index, embedding } of cacheResults) {
+    results[index] = embedding;
+  }
+  const toWrite = [];
+  if (cacheResults.length < texts.length) {
+    const missingIndexes = [...results.keys()].filter((i) => !results[i]);
+    const missingTexts = missingIndexes.map((i) => texts[i]);
+    const response = await fetchEmbeddingBatch(missingTexts);
+    if (response.embeddings.length !== missingIndexes.length) {
+      throw new Error(
+        `Expected ${missingIndexes.length} embeddings, got ${response.embeddings.length}`,
+      );
+    }
+    for (let i = 0; i < missingIndexes.length; i++) {
+      const resultIndex = missingIndexes[i];
+      toWrite.push({
+        textHash: textHashes[resultIndex],
+        embedding: response.embeddings[i],
+      });
+      results[resultIndex] = response.embeddings[i];
+    }
+  }
+  if (toWrite.length > 0) {
+    await ctx.runMutation(selfInternal.writeEmbeddings, { embeddings: toWrite });
+  }
+  return {
+    embeddings: results,
+    hits: cacheResults.length,
+    ms: Date.now() - start,
+  };
+}
+
+async function hashText(text: string) {
+  const textEncoder = new TextEncoder();
+  const buf = textEncoder.encode(text);
+  if (typeof crypto === 'undefined') {
+    // Ugly, ugly hax to get ESBuild to not try to bundle this node dependency.
+    const f = () => 'node:crypto';
+    const crypto = (await import(f())) as typeof import('crypto');
+    const hash = crypto.createHash('sha256');
+    hash.update(buf);
+    return hash.digest().buffer;
+  } else {
+    return await crypto.subtle.digest('SHA-256', buf);
+  }
+}
+
+export const getEmbeddingsByText = internalQuery({
+  args: { textHashes: v.array(v.bytes()) },
+  handler: async (
+    ctx,
+    args,
+  ): Promise<{ index: number; embeddingId: Id<'embeddingsCache'>; embedding: number[] }[]> => {
+    const out = [];
+    for (let i = 0; i < args.textHashes.length; i++) {
+      const textHash = args.textHashes[i];
+      const result = await ctx.db
+        .query('embeddingsCache')
+        .withIndex('text', (q) => q.eq('textHash', textHash))
+        .first();
+      if (result) {
+        out.push({
+          index: i,
+          embeddingId: result._id,
+          embedding: result.embedding,
+        });
+      }
+    }
+    return out;
+  },
+});
+
+export const writeEmbeddings = internalMutation({
+  args: {
+    embeddings: v.array(
+      v.object({
+        textHash: v.bytes(),
+        embedding: v.array(v.float64()),
+      }),
+    ),
+  },
+  handler: async (ctx, args): Promise<Id<'embeddingsCache'>[]> => {
+    const ids = [];
+    for (const embedding of args.embeddings) {
+      ids.push(await ctx.db.insert('embeddingsCache', embedding));
+    }
+    return ids;
+  },
+});