new functions added to conversations (#126)

* doing something!

* fix mypy

* fix

* fix

* onward

* wip

* killing it

* nicely failing test!

* better

* passing tests

* onward

* try this

* next

* use standardized types

* getting there!

* next

* ownard

* onward

* killing it

Author: eupharis

.gitignore

@@ -41,3 +41,4 @@ lerna-debug.log*
 
 # pycache
 __pycache__
+.mypy_cache/

prisma/migrations/20230323184833_add_functions_defined_and_webhooks_defined/migration.sql

@@ -0,0 +1,15 @@
+-- CreateTable
+CREATE TABLE "FunctionDefined" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "message_id" TEXT NOT NULL,
+    "function_id" INTEGER NOT NULL,
+    CONSTRAINT "FunctionDefined_message_id_fkey" FOREIGN KEY ("message_id") REFERENCES "conversation_message" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "WebhookDefined" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "message_id" TEXT NOT NULL,
+    "webhook_id" TEXT NOT NULL,
+    CONSTRAINT "WebhookDefined_message_id_fkey" FOREIGN KEY ("message_id") REFERENCES "conversation_message" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);

prisma/migrations/20230323223856_swap_name_to_public_id/migration.sql

@@ -0,0 +1,31 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `function_id` on the `FunctionDefined` table. All the data in the column will be lost.
+  - You are about to drop the column `webhook_id` on the `WebhookDefined` table. All the data in the column will be lost.
+  - Added the required column `functionPublicId` to the `FunctionDefined` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `webhookPublicId` to the `WebhookDefined` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_FunctionDefined" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "message_id" TEXT NOT NULL,
+    "functionPublicId" TEXT NOT NULL,
+    CONSTRAINT "FunctionDefined_message_id_fkey" FOREIGN KEY ("message_id") REFERENCES "conversation_message" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_FunctionDefined" ("id", "message_id") SELECT "id", "message_id" FROM "FunctionDefined";
+DROP TABLE "FunctionDefined";
+ALTER TABLE "new_FunctionDefined" RENAME TO "FunctionDefined";
+CREATE TABLE "new_WebhookDefined" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "message_id" TEXT NOT NULL,
+    "webhookPublicId" TEXT NOT NULL,
+    CONSTRAINT "WebhookDefined_message_id_fkey" FOREIGN KEY ("message_id") REFERENCES "conversation_message" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_WebhookDefined" ("id", "message_id") SELECT "id", "message_id" FROM "WebhookDefined";
+DROP TABLE "WebhookDefined";
+ALTER TABLE "new_WebhookDefined" RENAME TO "WebhookDefined";
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

prisma/migrations/20230323224034_change_table_names/migration.sql

@@ -0,0 +1,32 @@
+/*
+  Warnings:
+
+  - You are about to drop the `FunctionDefined` table. If the table is not empty, all the data it contains will be lost.
+  - You are about to drop the `WebhookDefined` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- DropTable
+PRAGMA foreign_keys=off;
+DROP TABLE "FunctionDefined";
+PRAGMA foreign_keys=on;
+
+-- DropTable
+PRAGMA foreign_keys=off;
+DROP TABLE "WebhookDefined";
+PRAGMA foreign_keys=on;
+
+-- CreateTable
+CREATE TABLE "function_defined" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "message_id" TEXT NOT NULL,
+    "functionPublicId" TEXT NOT NULL,
+    CONSTRAINT "function_defined_message_id_fkey" FOREIGN KEY ("message_id") REFERENCES "conversation_message" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "webhook_defined" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "message_id" TEXT NOT NULL,
+    "webhookPublicId" TEXT NOT NULL,
+    CONSTRAINT "webhook_defined_message_id_fkey" FOREIGN KEY ("message_id") REFERENCES "conversation_message" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);

prisma/schema.prisma

@@ -80,15 +80,36 @@ model WebhookHandle {
 model ConversationMessage {
   id        String   @id @default(uuid())
   createdAt DateTime @default(now())
-  user      User     @relation(fields: [userId], references: [id])
-  userId    Int      @map("user_id")
-  name      String   @default("") // not used for now. in future, will allow the user to have multiple conversations
-  role      String // assistant or user
-  content   String
+  user    User     @relation(fields: [userId], references: [id])
+  userId  Int      @map("user_id")
+  name    String   @default("") // not used for now. in future, will allow the user to have multiple conversations
+  role    String // assistant or user
+  content String
+  functions FunctionDefined[]
+  webhooks  WebhookDefined[]
 
   @@map("conversation_message")
 }
 
+model FunctionDefined {
+  id          Int         @id @default(autoincrement())
+  message     ConversationMessage @relation(fields: [messageId], references: [id])
+  messageId   String      @map("message_id")
+  functionPublicId  String  // could be a relation but isn't currently
+
+  @@map("function_defined")
+}
+
+
+model WebhookDefined {
+  id          Int         @id @default(autoincrement())
+  message     ConversationMessage @relation(fields: [messageId], references: [id])
+  messageId   String      @map("message_id")
+  webhookPublicId String  // could be a relation but isn't currently
+
+  @@map("webhook_defined")
+}
+
 // customizable prompt per user
 model SystemPrompt {
   id        String   @id @default(uuid())

science/completion.py

@@ -1,6 +1,8 @@
+import copy
 import requests
 import openai
-from typing import List, Dict, Optional
+import flask
+from typing import List, Dict, Optional, Set
 from prisma import get_client
 from prisma.models import ConversationMessage, SystemPrompt
 
@@ -9,7 +11,9 @@
 
 from utils import (
     FunctionDto,
+    MessageDict,
     WebhookDto,
+    clear_conversation,
     func_path_with_args,
     func_path,
     store_message,
@@ -37,7 +41,9 @@
     "the poly api library does not provide",
     "the poly api library doesn't provide",
 }
-NO_FUNCTION_ANSWER = "Poly doesn't know any functions to do that yet. But Poly would love to be taught!"
+NO_FUNCTION_ANSWER = (
+    "Poly doesn't know any functions to do that yet. But Poly would love to be taught!"
+)
 
 
 ADVERBS = {
@@ -50,7 +56,7 @@ def question_processing(question: str) -> str:
     # return question
 
 
-def answer_processing(from_openai: str):
+def answer_processing(from_openai: str) -> str:
     lowered = from_openai.strip().lower()
 
     # first strip off any common adverbs
@@ -77,9 +83,7 @@ def get_function_completion_answer(user_id: Optional[int], question: str) -> str
     if messages:
         return get_conversation_answer(user_id, messages, question)
     else:
-        functions = get_function_prompt()
-        webhooks = get_webhook_prompt()
-        return get_completion_answer(user_id, functions, webhooks, question)
+        return get_completion_answer(user_id, question)
 
 
 def get_conversations_for_user(user_id: Optional[int]) -> List[ConversationMessage]:
@@ -94,10 +98,16 @@ def get_conversations_for_user(user_id: Optional[int]) -> List[ConversationMessa
     )
 
 
-def get_function_prompt() -> str:
-    how_to_import = "To import the Poly API library, use `import poly from 'polyapi';`"
-    preface = "Here are the functions in the Poly API library,"
-    parts: List[str] = [how_to_import, preface]
+def get_function_message_dict(
+    already_defined: Optional[Set[str]] = None,
+) -> Optional[MessageDict]:
+    """get all functions (if any) that are not yet defined in the prompt
+    :param already_defined: a list of function public ids that are already defined
+    """
+    already_defined = already_defined or set()
+
+    preface = "Here are some functions in the Poly API library,"
+    parts: List[str] = [preface]
 
     db = get_client()
     user = db.user.find_first(where={"role": "ADMIN"})
@@ -108,14 +118,28 @@ def get_function_prompt() -> str:
     resp = requests.get(f"{NODE_API_URL}/functions", headers=headers)
     assert resp.status_code == 200, resp.content
     funcs: List[FunctionDto] = resp.json()
+
+    public_ids = []
     for func in funcs:
+        if func["id"] in already_defined:
+            continue
+
         parts.append(f"// {func['description']}\n{func_path_with_args(func)}")
+        public_ids.append(func["id"])
+
+    content = "\n\n".join(parts)
+    return {"role": "assistant", "content": content, "function_ids": public_ids}
 
-    return "\n\n".join(parts)
 
+def get_webhook_message_dict(
+    already_defined: Optional[Set[str]] = None,
+) -> Optional[MessageDict]:
+    """get all webhooks (if any) that are not yet defined in the prompt
+    :param already_defined: a list of webhook public ids that are already defined
+    """
+    already_defined = already_defined or set()
 
-def get_webhook_prompt() -> str:
-    preface = "Here are the event handlers in the Poly API library,"
+    preface = "Here are some event handlers in the Poly API library,"
     parts: List[str] = [preface]
 
     db = get_client()
@@ -126,11 +150,27 @@ def get_webhook_prompt() -> str:
     headers = {"Content-Type": "application/json", "X-PolyApiKey": user.apiKey}
     resp = requests.get(f"{NODE_API_URL}/webhooks/", headers=headers)
     assert resp.status_code == 200, resp.content
+
+    public_ids = []
     webhooks: List[WebhookDto] = resp.json()
+
     for webhook in webhooks:
+        if webhook["id"] in already_defined:
+            continue
+
         parts.append(webhook_prompt(webhook))
+        public_ids.append(webhook["id"])
+
+    if not public_ids:
+        # all the webhooks are already defined!
+        # let's go ahead and skip
+        return None
 
-    return "\n\n".join(parts)
+    return {
+        "role": "assistant",
+        "content": "\n\n".join(parts),
+        "webhook_ids": public_ids,
+    }
 
 
 def get_fine_tune_answer(question: str):
@@ -159,33 +199,84 @@ def webhook_prompt(hook: WebhookDto) -> str:
 def get_conversation_answer(
     user_id: Optional[int], messages: List[ConversationMessage], question: str
 ):
-    priors: List[Dict[str, str]] = []
+    # prepare payload
+    priors: List[MessageDict] = []
     for message in messages:
         priors.append({"role": message.role, "content": message.content})
 
-    question_message = {"role": "user", "content": question}
-    resp = openai.ChatCompletion.create(
-        model="gpt-3.5-turbo",
-        messages=priors + [question_message],
-    )
+    new_messages = get_new_conversation_messages(messages, question)
+
+    # get
+    try:
+        resp = get_chat_completion(priors + new_messages)
+    except openai.InvalidRequestError as e:
+        # our conversation is probably too long! let's transparently nuke it and start again
+        flask.current_app.log_exception(e)  # type: ignore
+        clear_conversation(user_id)
+        return get_completion_answer(user_id, question)
 
     answer = answer_processing(resp["choices"][0]["message"]["content"])
-    store_message(user_id, question_message)
+
+    # store
+    for message in new_messages:
+        store_message(user_id, message)
     store_message(user_id, {"role": "assistant", "content": answer})
+
     return answer
 
 
-def get_completion_prompt_messages(
-    functions: str, webhooks: str, question: str
-) -> List[Dict]:
+def get_new_conversation_messages(old_messages: List[ConversationMessage], question: str) -> List[MessageDict]:
+    """ get all the new messages that should be added to an existing conversation
+    """
+    rv = []
+
+    old_msg_ids = [m.id for m in old_messages]
+
+    db = get_client()
+    old_function_ids = {f.functionPublicId for f in db.functiondefined.find_many(where={"messageId": {"in": old_msg_ids}})}
+    old_webhook_ids = {w.webhookPublicId for w in db.webhookdefined.find_many(where={"messageId": {"in": old_msg_ids}})}
+
+    new_functions = get_webhook_message_dict(old_function_ids)
+    if new_functions:
+        rv.append(new_functions)
+
+    new_webhooks = get_webhook_message_dict(old_webhook_ids)
+    if new_webhooks:
+        rv.append(new_webhooks)
+
+    question_msg = MessageDict(role="user", content=question)
+    rv.append(question_msg)
+    return rv
+
+
+def get_chat_completion(messages: List[MessageDict]) -> Dict:
+    """ send the messages to OpenAI and get a response
+    """
+    stripped = copy.deepcopy(messages)
+    for s in stripped:
+        # pop off all the data we use internally before sending the messages to OpenAI
+        s.pop("function_ids", None)
+        s.pop("webhook_ids", None)
+
+    return openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=stripped,
+    )
+
+
+def get_completion_prompt_messages(question: str) -> List[MessageDict]:
+    function_message = get_function_message_dict()
+    webhook_message = get_webhook_message_dict()
+
     rv = [
-        {"role": "system", "content": "Include argument types. Be concise."},
-        {"role": "assistant", "content": functions},
-        {"role": "assistant", "content": webhooks},
-        # HACK To try to prevent Poly hallucinating functions we don't have
-        # https://github.com/polyapi/poly-alpha/issues/96
-        # {"role": "assistant", "content": "Only respond with functions and event handlers explicitly listed as part of the Poly API library. Do not use external APIs."},
-        {"role": "user", "content": question},
+        MessageDict(role="system", content="Include argument types. Be concise."),
+        MessageDict(
+            role="assistant",
+            content="To import the Poly API library, use `import poly from 'polyapi';`",
+        ),
+        function_message,
+        webhook_message,
+        MessageDict(role="user", content=question),
     ]
 
     system_prompt = get_system_prompt()
@@ -202,18 +293,18 @@ def get_system_prompt() -> Optional[SystemPrompt]:
     return system_prompt
 
 
-def get_completion_answer(
-    user_id: Optional[int], functions: str, webhooks: str, question: str
-) -> str:
-    messages = get_completion_prompt_messages(functions, webhooks, question)
-
-    model = "gpt-3.5-turbo"
-    # print(f"Using model: {model}")
-    resp = openai.ChatCompletion.create(model=model, messages=messages)
+def get_completion_answer(user_id: Optional[int], question: str) -> str:
+    messages = get_completion_prompt_messages(question)
+    resp = get_chat_completion(messages)
     answer = answer_processing(resp["choices"][0]["message"]["content"])
 
     for message in messages:
-        store_message(user_id, message)
+        store_message(
+            user_id,
+            message,
+            function_ids=message.get("function_ids", []),
+            webhook_ids=message.get("webhook_ids", []),
+        )
     store_message(user_id, {"role": "assistant", "content": answer})
 
     return answer