Custom GPT: "message": "The requested action requires approval

Before I go in: Yes, I know there are some of those things discussed in 2023, 2024 AND, I’ve researched ALL of them already.

Problem: Debug Info of Custom GPT shows that the function call needs approval

Does anyone else now encounter all of a sudden something similar?
Your custom gpt tries to call a function and suddenly you get this:

Done Manual Tests

When trying from my server (no matter if locally or online)

I get this for example:

{"message":"Memory server is operational.","status":"success"}

No errors. Works fine. Each time. No matter how fast and how many times I am calling it. Flawless

BUT, if my custom server tries it:

[debug] Calling HTTP endpoint
{
  "domain": "<static (fix) ngrok domain I am using online>",
  "method": "get",
  "path": "/memory/test",
  "operation": "testMemoryServer",
  "operation_hash": "bbadee4157726684fd554633169eeee86c91b139",
  "is_consequential": false,
  "params": {}
}
[debug] Response received
{
  "function_name": "testMemoryServer",
  "domain": "<static (fix) ngrok domain I am using online>",
  ***"message": "The requested action requires approval",***
  "action_id": "g-3a2a4cb2b6c1aec159f48ade0e16cb2fbe5a0299"
}

WHY does it need APPROVAL all of a sudden when it always worked before?
Anyone else facing the same?

The code didn’t even change since the end of last year for this.
Even in early January this year I used it for the last time. It worked.

Constellation

The server was running on my local computer.
The tunnel was created by ngrok command like this:

.\ngrok.exe http 5000 --domain <samedomain as above>

The token

ngrok config add-authtoken <authtoken>

is also still valid and has been set.

Those are the results from manually testing. Locally AND, preferrably, online.

For this json:

{
  "openapi": "3.1.0",
  "info": {
    "title": "Evelyn Memory API",
    "version": "1.0.0",
    "description": "API for managing memory entries for a custom GPT system."
  },
  "servers": [
    {
      "url": "https://usually-crucial-kodiak.ngrok-free.app/",
      "description": "Development server via ngrok"
    }
  ],
  "paths": {
    "/memory/write": {
      "post": {
        "summary": "Write a memory entry (plain text)",
        "operationId": "writePlainTextMemory",
        "requestBody": {
          "required": true,
          "content": {
            "text/plain": {
              "schema": {
                "type": "string"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Memory updated."
          },
          "400": {
            "description": "Content cannot be empty."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/writejson": {
      "post": {
        "summary": "Write a memory entry (JSON)",
        "operationId": "writeJsonMemory",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "content": {
                    "type": "string"
                  }
                },
                "required": [
                  "content"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Memory updated."
          },
          "400": {
            "description": "Content cannot be empty."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/read": {
      "get": {
        "summary": "Read all memory entries",
        "operationId": "readMemory",
        "responses": {
          "200": {
            "description": "List of memory entries",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "entries": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "Memory file not found."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/write_bulk": {
      "post": {
        "summary": "Write multiple memory entries",
        "operationId": "writeBulkMemory",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "entries": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  }
                },
                "required": [
                  "entries"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Bulk memory entries added."
          },
          "400": {
            "description": "Entries cannot be empty."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/search": {
      "get": {
        "summary": "Search memory entries",
        "operationId": "searchMemory",
        "parameters": [
          {
            "name": "keyword",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Matching entries found",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "matches": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "No matches found."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/search/advanced": {
      "get": {
        "summary": "Advanced search with optional date",
        "operationId": "advancedSearchMemory",
        "parameters": [
          {
            "name": "keyword",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "date",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Matching entries found",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "matches": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  }
                }
              }
            }
          },
          "404": {
            "description": "No matches found."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/edit": {
      "put": {
        "summary": "Edit a memory entry by line number",
        "operationId": "editMemoryEntry",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "line_number": {
                    "type": "integer"
                  },
                  "new_content": {
                    "type": "string"
                  }
                },
                "required": [
                  "line_number",
                  "new_content"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Memory entry updated."
          },
          "400": {
            "description": "Invalid line number or content."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/delete": {
      "delete": {
        "summary": "Delete a memory entry by line number",
        "operationId": "deleteMemoryEntry",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "line_number": {
                    "type": "integer"
                  }
                },
                "required": [
                  "line_number"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Entry deleted."
          },
          "400": {
            "description": "Invalid line number."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/clear": {
      "delete": {
        "summary": "Clear all memory entries",
        "operationId": "clearAllMemory",
        "responses": {
          "200": {
            "description": "All memory cleared."
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/test": {
      "get": {
        "summary": "Test memory server",
        "operationId": "testMemoryServer",
        "responses": {
          "200": {
            "description": "Memory server is operational.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "status": {
                      "type": "string"
                    },
                    "message": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    },
    "/memory/backup": {
      "post": {
        "summary": "Create a backup of the memory file",
        "operationId": "createMemoryBackup",
        "responses": {
          "200": {
            "description": "Backup created successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "status": {
                      "type": "string"
                    },
                    "message": {
                      "type": "string"
                    },
                    "backup_filename": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal server error."
          }
        }
      }
    }
  }
}

Anyone got any clue or a similar or the same problem? Still wasn’t able to solve it, yet.

Yes, I got the same issue when using ngrok to build the tunnel to my localhost. Have you solved this issue yet?

Finally, let’s see if it solved itself or not.
Just saw your message right now.
So let me try right now. :smiley:

This is “solved”: Custom GPT Actions "Talking to connector" (unless otherwise noted here)

See also here:

P.S.: Seems like OpenAI have tightened the gates without telling explicitly that is.