What is Pydantic and Why Is It Broken in Poe?

Short answer: Pydantic is a Python data validation library that Poe’s Script-Bot Creator uses under the hood to validate its outputs. When people ask “what is Pydantic” in the context of Script-Bot Creator, they usually mean it because they’re hitting a validation error (something like “Input should be a valid dictionary or instance of…” referencing CallToolResult, TextContent, or EmbeddedResource) at the very last step — the step where Script-Bot Creator is supposed to hand you a finished .zip file. That final delivery step is broken right now. The good news: there is a reliable workaround, and you do not need to rebuild anything you already made in the conversation.

The fix in one sentence: stop asking Script-Bot Creator to deliver a zip, and instead ask it to repackage the same files you already have into a single build.sh script that you run locally to produce the zip yourself.

The Solution: Copy-Paste This Prompt Into Script-Bot Creator

When Script-Bot Creator finishes working on your project but fails on the final zip step with a Pydantic validation error, paste the following prompt as your next message in that same conversation. Do not start a new chat — you want Script-Bot Creator to remember every file it already built.

Pydantic is currently broken in Script-Bot-Creator, so the usual "package files into a zip and hand it to me" step is failing with validation errors (CallToolResult / TextContent / EmbeddedResource). Do NOT try to deliver a zip. Do NOT try to attach files directly. Switch to the workaround below.
Keep every file you've already generated in this conversation. Do not regenerate them from scratch. Just repackage the delivery.
CRITICAL FORMATTING RULE: The entire build.sh must be wrapped in exactly ONE outer code fence using SIX backticks followed by the word bash, and closed with six backticks on their own line at the very end. Do NOT use triple-backtick fences anywhere inside build.sh — the six-backtick outer fence makes any inner backticks literal, so Poe renders the whole thing as one single code widget with one "bash" label instead of breaking it into dozens of mini-widgets whose language labels ("php", "scheme", "json") contaminate copy-paste.
Your entire reply should contain exactly THREE things, in this order, and nothing else:
FIRST — inside its own triple-backtick code fence — this cleanup command exactly as written, on one line:
python3 -c 'import re;p="build.sh";s=open(p).read();s=re.sub(r"^[+]\s+\d+\s?","",s,flags=re.M);bad={"php","bash","scheme","json","applescript","python","javascript","html","css","sql","yaml","xml","typescript","ruby","perl","go","rust","java","c","cpp"};s="\n".join(l for l in s.split("\n") if l.strip() not in bad);open(p,"w").write(s);print("cleaned",p)'
SECOND — the complete build.sh wrapped in a single six-backtick bash fence as described above.
THIRD — inside its own triple-backtick code fence — this single run command on one line:
bash build.sh
Do NOT explain any of the three items. Do NOT warn about copy-paste prefixes. Do NOT add any text before, between, or after those three items. Just the cleanup command, then the build.sh fence, then the run command. Nothing else.
Requirements for build.sh:
Starts with a bash shebang line (#!/usr/bin/env bash) followed by set -euo pipefail. Captures the starting directory with START_DIR="$(pwd)". Creates a clean working directory (BUILD_DIR="$START_DIR/build-output"), removing it first if it exists. Writes every file using Python heredocs: python3 with a quoted 'PY' marker, pathlib.Path to mkdir parents with parents=True and exist_ok=True, and write_text with a raw triple-quoted string. For edits to existing files, use the "assert old in s" pattern: read file into s, define old and new, assert old in s with a clear error message, then write back s.replace(old, new). Build halts loudly if an anchor is missing. Bumps version numbers in headers and constants with a short comment noting each bump. Echoes progress between every major step. Builds the final zip using Python's zipfile module (NOT the system zip command): ZipFile in write mode with ZIP_DEFLATED, walk build-output with rglob, write each file using its path relative to the build-output parent. Name it projectname-vX.Y.Z.zip. Print final path and size. Ends with a verification block printing the zip location, size, and contents listing.
The entire build.sh must be delivered in one single reply inside one single six-backtick bash fence. Produce the cleanup command, build.sh, and the run command now. No other text.

That is the entire workaround prompt. Send it as-is. Script-Bot Creator will reply with three things: a cleanup command, a build.sh file, and a run command.

The Exact Steps To Turn That Reply Into A Working Zip

1. Make a new folder anywhere convenient — name it something descriptive for your project.
2. Inside that folder, create a blank text file and call it build.txt.
3. Open build.txt and paste in the entire build.sh content that Script-Bot Creator just gave you (everything inside the six-backtick bash fence).
4. Rename the file from build.txt to build.sh (or to whatever specific filename the bot told you to use, e.g. build-motron-theme.sh).
5. Open Terminal and cd into the folder. The easiest way is to type cd (with a trailing space) and then drag the folder icon onto the Terminal window — it fills in the path for you.
6. Run the cleanup command Script-Bot Creator gave you first (the one-line python3 -c '...' command). This strips any stray language-label contamination out of the pasted text.
7. Run bash build.sh. It prints progress as it goes, writes every file using Python heredocs, and finishes by producing your zip.
8. Upload the resulting zip to WordPress (or wherever it’s destined). Done.

That’s it. If the Pydantic error returns on the final step of any future Script-Bot Creator job, come back here, grab the prompt again, and you have your answer to “what is Pydantic doing to my workflow, and how do I get around it.”

Why This Workaround Exists

Script-Bot Creator on Poe Ai s a tool where you can say:

“Do step one, step two, step three, and then wrap it all up in a zip file I can download,”

It generally works just like you’ve asked, and that’s amazing because its like having a team of geniuses working for you, and they’ll work toward whatever goal you’ve set.

The problem: recently the very last step — the delivery of the zip — stopped working. It throws an error about Pydantic validation, something like “Input should be a valid dictionary of embedded…” referencing CallToolResult, TextContent, and EmbeddedResource. To the end user, that failure makes the whole tool basically worthless until you know how to fix it, because how does this do its job anymore if I can’t even test it?

After two days of this being down, the solution I figured out — using Script-Bot Creator itself — is to ask it to repackage everything it already made into a local-build script instead of a zip. The prompt above does that cleanly and reliably. Every file it already generated in the conversation stays intact; it just swaps the delivery mechanism from “zip attachment” (broken) to “bash script you run on your own machine” (works).

Sidebar: How To Dictate Long Prompts Into Any AI Chat

One of the reasons Script-Bot Creator works so well for big, multi-step projects is that you can describe exactly what you want in as much detail as you want — and the easiest way to feed it that much detail is to talk the prompt instead of typing it. Here’s the shortcut for Apple devices:

1. Open the Voice Memos app.
2. Tap record and start describing your project out loud. It could be eight and a half minutes long. Doesn’t matter.
3. When you’re done, stop the recording, open the memo, and tap View Transcript. Apple’s on-device speech-to-text is very accurate.
4. Tap Copy Transcript.
5. Paste the transcript into Poe (or any AI chat) as your prompt.

That’s how I fit as much text-to-speech as I want into any AI conversation. I talk to my phone for minutes at a time, I dictate it, and then I copy that dictation into Poe and send it. It’s the fastest way to brief a model like Claude Opus on something big — like, say, a custom WordPress theme with dozens of specific requirements.

The Use Case: Building WordPress Themes With Script-Bot Creator

The project I was working on when I hit the Pydantic error was a WordPress theme. When you run a website on the back end of WordPress, you can change its appearance by its theme. There are lots of pre-made themes available, or if you know how to code, you can make your own theme according to your own taste. I don’t know how to code my own theme, but I do know what to ask for, and I ask Script-Bot Creator to do stuff all the time.

The workflow looks like this: I dictate an eight-minute voice memo describing the theme — layout, fonts, menu structure, archive pages, custom post types, the whole thing — I transcribe it, I paste the transcript into Poe with Script-Bot Creator, and I let it iterate. Five or ten minutes later I have something that might have taken a team of software engineers a whole week. With the Pydantic workaround above, the final delivery step works again: I get my zip, I upload it in the WordPress admin under Appearance → Themes → Add New → Upload Theme, activate it, refresh the front end, and the new theme is live. Then I just keep iterating — “make all the pages, get graphics, up to ten” — and it keeps building.

What Is Pydantic, Actually? (Technical Background)

Now for the deeper answer to “what is Pydantic” — the one you’d want if you were trying to understand why the error exists in the first place.

Pydantic is the most widely used data-validation library for Python. It lets developers define the shape of data using standard Python type hints, and then it enforces that shape at runtime. If data comes in that doesn’t match — wrong type, missing field, unexpected structure — Pydantic raises a ValidationError describing exactly what went wrong and where.

A few key things about Pydantic:

• Type-hint based. You write a class that inherits from BaseModel, declare fields with Python type annotations (str, int, list[str], custom nested models, etc.), and Pydantic generates a schema from that class.
• Runtime validation and coercion. When you create an instance of the model, Pydantic checks every field. If the data is valid, you get a normal Python object. If not, you get a detailed error.
• Used everywhere in the modern Python AI stack. FastAPI, LangChain, the OpenAI SDK, the Anthropic SDK, Poe’s own tooling, and countless MCP (Model Context Protocol) servers all use Pydantic models to define the shape of tool calls, tool results, messages, and attachments.
• V1 vs. V2. Pydantic V2 (released 2023) was a major rewrite with a Rust-based core. A lot of breakage in the Python AI ecosystem over the last couple of years traces back to libraries that shipped Pydantic V1 models being pulled into environments that expect V2, or vice versa.

In Script-Bot Creator’s case, the final “deliver a zip” step internally constructs a tool-result object that contains an embedded file resource. That object is defined as a Pydantic model — specifically something like CallToolResult containing a list of items that must each be either TextContent or EmbeddedResource. Something in the current build is producing output that doesn’t validate against that schema, so Pydantic refuses to emit it and the whole step fails loudly. That’s the error you’re seeing.

The workaround above sidesteps Pydantic’s validation entirely by not using the attachment delivery path at all. Instead of returning an EmbeddedResource, Script-Bot Creator returns plain text (the build.sh contents) inside a code fence — which is just TextContent, which validates fine — and you do the zip-packaging locally on your own machine.

If you want to read the official docs for the library itself, they live at docs.pydantic.dev.

TL;DR

• What is Pydantic? A Python validation library that Script-Bot Creator relies on for its tool-result schema.
• What’s broken? The final zip-delivery step fails Pydantic validation (CallToolResult / TextContent / EmbeddedResource errors).
• What’s the fix? Paste the prompt above into the same Script-Bot Creator conversation, save the returned build.sh, run the cleanup command, then run bash build.sh. Your zip appears in build-output.
• Bonus tip: dictate big prompts into Apple Voice Memos, copy the transcript, paste it into Poe. That’s how you brief Script-Bot Creator on complex projects without typing for an hour.

Hopefully this article saves you the two days it took me to figure out what Pydantic has to do with any of this. Have a nice one.