没有不值得去解决的问题,也没有不值得去学习的技术!

Automating WordPress Historical Posts Hits GLM 1301: From HTTP 400 to ChatGPT Manual Fallback

Figure 5: The article is ultimately completed, but the original excerpt_generation_failed, HTTP 400, and manual completion records are all preserved.

Recently, I have been continuing to process the remaining historical articles according to the currently primary WordPress historical article processing SOP.

This SOP has undergone multiple rounds of validation with real batches. The current daily workflow roughly consists of fixed batches, Gutenberg normalization, production read-only verification, Chinese excerpt generation, English override translation, failure recovery, and final completed status confirmation.

An earlier phase of the workflow is documented in Batch Processing 20 WordPress Historical Articles Daily: A Complete SOP for Code Block Migration, Excerpt Completion, and English Override Translation.

As work on subsequent historical articles continues, my actual operations now primarily reference the SOP updated on July 30, rather than starting over from the earliest workflow.

A few days ago, I actually encountered a situation where automated processing could not complete successfully, and I ultimately switched to manual processing. I chose to have ChatGPT take over the required content, and then manually completed the article processing in WordPress. That process was recorded in a historical article processed manually a few days ago.

Today, while continuing to process a new fixed batch of 20 articles, I encountered another exception scenario better suited for formal inclusion in the SOP:

The automated workflow had not even entered the English override translation phase yet when it continuously received GLM HTTP 400 errors during Chinese excerpt generation.

After multiple real retries, execution evidence checks, and offline analysis, I finally confirmed that this was not ordinary network fluctuation, but rather GLM explicitly triggering content safety filtering.

This time, I did not modify the original historical article to pass the model’s review. Instead, I further refined the existing manual fallback process:

Plaintext
Deterministic rejection by automated model
→ Stop meaningless retries
→ ChatGPT manually generates Chinese excerpt
→ ChatGPT manually completes English title, excerpt, and body
→ Manually write back to WordPress
→ mark-manual-completed production read-only acceptance
→ Preserve original failure evidence
→ coordination state safely converges to completed

Ultimately, this batch still achieved 20 / 20 fully completed.


1. Only One Article Left Out of 20, but Excerpt Generation Continues with HTTP 400

The batch being processed this time was:

Plaintext
mixed-syntaxhighlighter-20260814-03

The entire batch consisted of 20 articles, of which 19 were completed normally, leaving only:

Plaintext
zh=7756
en=10072

The corresponding Chinese article title is:

The Process of Transferring USDT from OKX to MEXC via ARB Cross-Chain

This is a historical operation record. The body contains content such as MEXC, OKX, USDT, Arbitrum One, deposit addresses, withdrawal networks, transaction fees, and arrival records.

This failure occurred earlier than the English translation phase.

The execution evidence shows:

Plaintext
status: excerpt_generation_failed
error: HTTP request failed with status 400

If we only looked at the HTTP 400, it would actually be difficult to determine whether it was:

Plaintext
Request parameter exception
Input content issue
Model service exception
Network fluctuation
Content moderation

Therefore, I continued to examine the saved structured GLM response.

The truly critical information finally appeared:

Plaintext
error.code = 1301

Along with:

Plaintext
contentFilter:
role = assistant
level = 1

The information returned by the model also explicitly pointed to content safety filtering.

Figure 1: Article 7756 returned HTTP 400 during the Chinese excerpt generation phase; further inspection of the GLM response confirmed a 1301 content filtering result.
Figure 1: Article 7756 returned HTTP 400 during the Chinese excerpt generation phase; further inspection of the GLM response confirmed a 1301 content filtering result.

At this point, the problem should no longer be treated simply as a “network error.”


2. A Single TimeoutError Cannot Explain the Recurring HTTP 400

During this troubleshooting process, there was indeed one occurrence of:

Plaintext
TimeoutError

So initially, there was a question:

Could it just be that the GLM service was unstable at that time?

However, after putting the entire sequence of failures together, it became quite clear:

Plaintext
HTTP 400
→ HTTP 400
→ HTTP 400
→ recover
→ TimeoutError
→ recover
→ HTTP 400

The TimeoutError in the middle can be viewed independently as a temporary network request exception.

However, the consistently recurring HTTP 400 errors before and after it obviously cannot all be explained by network fluctuation.

The subsequent code also further enhanced diagnostic information, allowing the HTTP status, structured error response, and GLM request size to be included in the execution evidence.

This way, when encountering similar errors in the future, there is no need to stare only at a long Python traceback.


3. After Offline Inspection, Input Length Issues Were Ruled Out

To further confirm the cause, I pulled the production Chinese source read-only to my local machine and verified that the SHA-256 matched the production source digest saved by the program exactly.

Then I used the following from the production code:

Plaintext
extract_excerpt_source()

to regenerate the actual excerpt input sent to GLM.

The results were:

Plaintext
Original body:
8228 chars
10234 bytes

Cleaned body:
892 chars
2024 bytes

Full GLM payload:
3427 bytes

In other words, the actual content sent to GLM for this article was not long.

The current excerpt extraction logic itself allows for inputs far larger than this scale, so there is no evidence that the HTTP 400 was caused by the body being too long or the request body being too large.

What is truly quite specific is that, after cleaning out Gutenberg comments, HTML tags, and other content, the remaining body still continuously contained:

Plaintext
USDT
Arbitrum One
MEXC
OKX
Deposit
Withdrawal
On-chain network
Full address
Transfer amount
Transaction fee
Arrival record

This combination of content very likely triggered the model’s content moderation.

However, the existing evidence can only prove that:

GLM 1301 content filtering was the direct cause of this HTTP 400.

As to exactly which sentence, which address, or which category of words triggered it, the current evidence is insufficient to determine precisely.


4. I Do Not Intend to Modify Historical Articles to Pass the Model’s Review

After confirming it was model content filtering, there was actually another way to handle it.

I could have continuously modified the Chinese source:

Plaintext
Delete potentially sensitive words
→ Delete addresses
→ Simplify amount descriptions
→ Modify transfer steps
→ Request GLM again
→ Until the model accepts it

But I ultimately did not choose this direction.

The original goals of processing historical articles were:

Plaintext
Standardize historical formats
Fill in missing Chinese excerpts
Redo English translations

Not:

Plaintext
Modifying the original article content
To accommodate the current review rules of a specific model

This article in particular records a real historical operation process.

If I deleted networks, amounts, addresses, or operation steps for the sake of model review, it would ultimately destroy the historical record itself.

So, once I determined that the HTTP 400 was due to model content filtering, I felt that continuing to blindly call GLM was no longer meaningful.

A more reasonable approach was:

Plaintext
Preserve the automated failure facts
→ Stop automated retries
→ Switch to manual fallback

5. The ChatGPT Manual Processing Route Was Already Validated a Few Days Ago

This was not the first time I considered manual intervention.

When processing another abnormal historical article a few days ago, the automated workflow similarly could not complete smoothly, and I ultimately tried manual processing via ChatGPT.

The relevant process is recorded in:

A historical article processed manually a few days ago

That practice validated at least one thing:

When the automated workflow encounters a few articles it cannot push forward, there is no need to stall the entire batch.

That article can be individually moved to manual processing.

However, today article 7756 exposed a new boundary.

The previous manual completion mechanism primarily considered:

Plaintext
translation_failed
blocked

But 7756 stopped at:

Plaintext
excerpt_failed

That is:

This time, even the Chinese excerpt had not been generated successfully yet.

Therefore, the original manual completion entry point could not directly and safely cover this situation.


6. The Original mark-manual-completed Did Not Support excerpt_failed

The repository already had a command specifically for external manual completion:

Bash
python3 bin/history-migration.py mark-manual-completed \
    --post-id 文章ID

The formal confirmation was:

Bash
python3 bin/history-migration.py mark-manual-completed \
    --post-id 文章ID \
    --confirmed

This design itself is well-suited for ChatGPT manual fallback.

The problem was that the original allowed states were primarily:

Plaintext
translation_failed
blocked

While the current article was:

Plaintext
excerpt_failed

These two situations cannot be simply equated.

If it was translation_failed, it usually meant:

Plaintext
Chinese excerpt was generated
→ Chinese excerpt was written
→ English override translation phase failed

But excerpt_failed meant:

Plaintext
The Chinese excerpt had not even been successfully generated

If I simply added:

Plaintext
excerpt_failed

to the allowed states without adding extra checks, the following could occur:

Plaintext
Chinese excerpt is still empty
→ English article originally had content
→ mark-manual-completed mistakenly assumes manual work is done
→ workflow_status = completed

This is obviously unsafe.


7. Adding Stricter Manual Completion Checks for excerpt_failed

Therefore, I made a very small but crucial extension to mark-manual-completed this time.

excerpt_failed can now enter the manual completion check, but it must simultaneously satisfy:

Plaintext
Chinese article ID is correct
Chinese article status = publish
Chinese post_excerpt is not empty

English article ID is correct
English article status = publish
English title is not empty
English content is not empty

Polylang Chinese-English relationship is bidirectionally correct

The key check that was truly added is:

Plaintext
Chinese excerpt is not empty

And this condition only applies to:

Plaintext
excerpt_failed

The original:

Plaintext
translation_failed
blocked

behavior was not unconditionally relaxed as a result.


8. The First Preview Correctly Prevented Manual Completion

After modifying the code and passing tests, I did not immediately start modifying WordPress.

I first ran a Preview directly using the current real article 7756:

Bash
cd ~/code/wordpress-ai-excerpt-backfill

python3 bin/history-migration.py mark-manual-completed \
    --post-id 7756

At that time, the Chinese excerpt was still empty.

The program output:

Plaintext
Mode: preview
Article: zh=7756 en=10072
Current status: excerpt_failed
Read-only checks: post ID, publish, Polylang, English title and body (excerpt_failed additionally checks Chinese excerpt)
Allow manual completion: No
Write operations: No
Block reason: Chinese excerpt is empty

This result was exactly what I wanted to see.

It proved that the program did not mistakenly identify this article as “already manually processed” just because the English historical article originally had a title and body.

The Chinese excerpt had to be filled in first.


9. ChatGPT Manually Generates the Chinese Excerpt

Subsequently, I directly copied the article title and the full Gutenberg body from the WordPress editor and gave it to ChatGPT.

ChatGPT regenerated the Chinese excerpt based on the full original text:

This article records the actual process of transferring USDT from OKX to MEXC via the Arbitrum One network, including generating a deposit address on MEXC, selecting USDT and the corresponding withdrawal network on OKX, verifying the address and network, completing email and phone verification, checking the withdrawal status, and confirming the arrival through a small test transfer followed by subsequent transfers. The process also records platform risk warnings, transaction fees, and account balance changes, emphasizing that cross-platform transfers must use the same network for deposit and withdrawal, and that addresses must be carefully verified to avoid asset loss due to incorrect network or address selection.

Then I manually filled it into the excerpt field of the Chinese article in WordPress.

Figure 2: After continuous failures with GLM automated excerpt generation, ChatGPT was used to generate the Chinese excerpt based on the full body, which was then manually saved back to WordPress.
Figure 2: After continuous failures with GLM automated excerpt generation, ChatGPT was used to generate the Chinese excerpt based on the full body, which was then manually saved back to WordPress.

Here, the Chinese body was not modified to bypass moderation.

The only real addition was the previously missing post_excerpt.


10. ChatGPT Simultaneously Redoes the English Article

Since this article had already entered manual fallback, I ultimately did not let the automated translation pipeline continue handling the subsequent English override translation.

Instead, I had ChatGPT directly complete:

Plaintext
English title
English excerpt
Full English body
Image alt
Figure caption

The final English title was:

Plaintext
Transferring USDT from OKX to MEXC via Arbitrum: The Process

The body continued to preserve the original Gutenberg structure:

Plaintext
Paragraph order unchanged
Image blocks unchanged
Image IDs unchanged
Media URLs unchanged
Full addresses unchanged

Only the natural language content was retranslated.

Figure 3: After ChatGPT manually completed the English title, body, and excerpt, they were saved back to the original English WordPress article.
Figure 3: After ChatGPT manually completed the English title, body, and excerpt, they were saved back to the original English WordPress article.

With this, the actual content in the production environment met the requirements for manual completion.

However, at this point, I still did not manually modify the state JSON.


11. The Program Only Allowed Manual Completion After Re-running the Preview

After manually saving the Chinese excerpt and English content, I ran the same Preview again:

Bash
cd ~/code/wordpress-ai-excerpt-backfill

python3 bin/history-migration.py mark-manual-completed \
    --post-id 7756

This time, the result changed to:

Plaintext
Mode: preview
Article: zh=7756 en=10072
Current status: excerpt_failed
Read-only checks: post ID, publish, Polylang, English title and body (excerpt_failed additionally checks Chinese excerpt)
Allow manual completion: Yes
Write operations: No

This meant the program had confirmed via a production read-only query that:

Plaintext
Chinese excerpt exists
Chinese article is normally published

English title exists
English body exists
English article is normally published

Polylang Chinese-English correspondence is normal

Only after the actual content in the production environment met the requirements was proceeding to the next step allowed.

This is much more reliable than directly modifying the local:

Plaintext
workflow_status = completed

It is far more reliable.


12. Finally Executing –confirmed

Preview confirmed:

Plaintext
Allow manual completion: Yes

After that, I formally executed:

Bash
cd ~/code/wordpress-ai-excerpt-backfill

python3 bin/history-migration.py mark-manual-completed \
    --post-id 7756 \
    --confirmed

The real output was:

Plaintext
Mode: confirmed
Article: zh=7756 en=10072
Current status: excerpt_failed
Read-only checks: post ID, publish, Polylang, English title and body (excerpt_failed additionally checks Chinese excerpt)
Allow manual completion: Yes
Write operations: Yes
Figure 4: After production read-only checks confirmed that the Chinese excerpt, English article, and Polylang were all normal, formal confirmation of manual completion was allowed.
Figure 4: After production read-only checks confirmed that the Chinese excerpt, English article, and Polylang were all normal, formal confirmation of manual completion was allowed.

It should be specifically noted that the following here:

Plaintext
Write operations: Yes

does not mean modifying WordPress again.

The content in WordPress had already been manually saved by me.

This command writes to the local coordination state.

It ultimately adds:

JSON
"manual_completion": {
    "status": "confirmed",
    "method": "manual_external"
}

And updates:

Plaintext
workflow_status

to:

Plaintext
completed

13. completed Does Not Disguise the Original Automated Failure as a Success

This time, I was particularly concerned about one issue:

Since it was later completed manually, what should happen to the original GLM failure evidence?

My choice was:

Do not modify it.

The final article status was:

Plaintext
workflow_status: completed

But the execution evidence still clearly records:

Plaintext
status: excerpt_generation_failed

The last automated failure is also preserved:

Plaintext
HTTP request failed with status 400
reason: http_client_error

At the same time, the following was added:

Plaintext
manual_completion:
method: manual_external
status: confirmed
Figure 5: The article is ultimately completed, but the original excerpt_generation_failed, HTTP 400, and manual completion records are all preserved.
Figure 5: The article is ultimately completed, but the original excerpt_generation_failed, HTTP 400, and manual completion records are all preserved.

I think this state is more factual than directly changing the execution evidence to:

Plaintext
success

What actually happened was:

Plaintext
Automated excerpt failure
+
Manual external completion
=
Final business goal achieved

These three things can absolutely coexist.

completed means:

The current historical article migration task is complete.

It does not mean:

The previous automated execution never failed.


14. The Entire Batch Ultimately Recovered to 20 / 20 completed

Finally, I rechecked the entire batch:

Bash
cd ~/code/wordpress-ai-excerpt-backfill

echo "========== FINAL RESULT =========="

python3 bin/history-migration.py summary \
    | grep -E \
    'mixed-syntaxhighlighter-20260814-03|最新未完成批次|建议创建下一批|建议:'

The final output:

Plaintext
mixed-syntaxhighlighter-20260814-03:
total=20
completed=20
remaining=0

Latest incomplete batch: None
Suggest creating next batch: True
Suggestion: all batches complete
Figure 6: After the last article was handled via ChatGPT manual fallback, the entire batch reached completed=20 and remaining=0 again, allowing the next batch to be created.
Figure 6: After the last article was handled via ChatGPT manual fallback, the entire batch reached completed=20, remaining=0 again, allowing the next batch to be created.

This means:

One article being rejected by the model did not cause the entire historical article migration batch to be stuck indefinitely.


15. The SOP Now Has a Formal Manual Fallback Path

Under normal circumstances, the daily main workflow remains unchanged:

Plaintext
Create fixed batch
→ Manual check / Gutenberg normalization
→ mark-converted
→ Production read-only verification
→ run-ready --execute
→ completed

After a normal single-article failure occurs during the formal execution phase, it still prioritizes:

Plaintext
recover --post-id
→ Program determines recovery strategy
→ recover --execute

For example, the program can automatically determine based on production source, pre-write baseline, and execution evidence:

Plaintext
resume
restart_from_current
blocked
none

Manual processing from a few days ago already proved that:

A very small number of abnormal articles can be individually taken over by ChatGPT.

And today, article 7756 further formally integrated this route into the state machine.

Now, when encountering a similar deterministic model rejection, you can follow:

Plaintext
GLM excerpt continuous failure
→ recover / execution evidence confirms the real cause
→ Confirm it is a deterministic failure like model content filtering
→ Stop blind retries

→ ChatGPT generates Chinese excerpt
→ ChatGPT generates English title, excerpt, and full body
→ Manually save to WordPress

→ mark-manual-completed Preview
→ Production read-only checks
→ Confirm manual completion is allowed

→ mark-manual-completed --confirmed
→ workflow_status = completed

Throughout this process:

Plaintext
Do not delete state
Do not clear evidence
Do not manually fake completed
Do not modify original failure records

This path has also been incorporated into the currently primary WordPress historical article processing SOP.

When encountering similar problems in the future, there is no need to try to remember:

Plaintext
What command should be executed after manual translation is complete?
Does the JSON need to be modified?
How can this article be moved to completed?

Just run:

Plaintext
mark-manual-completed

and that’s it.


16. Why I Think This Addition Is Not Just a Command, But a State Design

As historical article automated processing progresses, the vast majority of ordinary articles have actually become increasingly stable.

What usually consumes time are the few exceptions.

For example, the ones actually encountered so far include:

Plaintext
SSH timeout
REST authentication exception
GLM TimeoutError
Protected Token validation failure
WordPress HTTP 500
Ctrl+C interruption
Execution evidence inconsistent with workflow
Model content filtering

If every time an exception occurs, it is resolved by:

Plaintext
Deleting state
Clearing evidence
Modifying JSON
Forcing completed

then as the project goes on longer, the local state will ultimately become increasingly untrustworthy.

I now prefer to maintain a rather clear principle:

If the automated process fails, save the automated failure.

If manual completion is done, record the manual completion.

The final workflow state only expresses whether the current task is complete.

This way, when reviewing a historical article later, it will still be possible to answer:

Plaintext
Why did it fail at that time?
Where did the automated workflow execute to?
What was the real error?
Was the production content modified afterwards?
Who ultimately completed it?
Did it pass production checks?
Why was it ultimately allowed to enter completed?

This is more valuable than just seeing:

Plaintext
completed

as the only result.


17. We Need to Continue Observing the Content Moderation Strictness of Different Large Models

This GLM 1301 incident also made me reconsider the choice of models during the historical article automation process.

For ordinary technical content, GLM’s automated excerpt generation and translation across a large volume of historical articles is currently working normally overall.

But this article was rather special.

It continuously involved:

Plaintext
Digital assets
Deposit
Withdrawal
On-chain addresses
Network selection
Amounts
Transaction fees
Account balances
Arrival records

Even if the original article itself merely records a normal operation process, it may still be intercepted by the model’s content moderation.

Going forward, I plan to continue practically testing the moderation strictness of different domestic large models on this type of article.

I will focus on observing several factors:

Plaintext
Chinese comprehension and generation quality
API stability
Invocation cost
Long-text capability
Structured output capability
False moderation interceptions

To see if there are domestic models with moderation strictness that is relatively more suitable for processing historical content on a technical blog.

From my current experience actually using different models, some overseas large models encounter fewer similar false interceptions when processing such normal technical records.

However, this observation cannot yet be simply generalized as:

Plaintext
Domestic models all strictly moderate
Overseas models do not moderate at all

Safety policies from different vendors, different models, and even different time periods can all change.

Therefore, continued verification through real API calls is still needed.

I also do not intend to chronically modify my historical articles to accommodate the content moderation rules of a specific model.

I prefer that the subsequent workflow continues to develop in this direction:

Plaintext
Model A completes normally
→ completed

Model A temporary failure
→ Limited retries

Model A deterministic rejection
→ Stop meaningless retries
→ Try Model B

Model B still cannot process
→ ChatGPT / manual fallback
→ Production acceptance
→ manual completion
→ completed

If such cases continue to appear in the future, the next phase could even consider evolving the current:

Plaintext
Manual ChatGPT fallback

further into:

Plaintext
Multi-model automated fallback

This would compress manual intervention down to the very few articles that truly require human judgment.


Summary

Today started out as just a very ordinary batch processing exception.

Out of the 20 articles:

Plaintext
19 completed normally
1 failed during Chinese excerpt generation

Initially, all I saw was:

Plaintext
HTTP 400

After further inspection, it was finally confirmed:

Plaintext
HTTP 400
→ GLM error.code = 1301
→ contentFilter
→ Content safety filtering

Subsequently, through the real Chinese source and the production excerpt extraction logic, it was confirmed that:

Plaintext
cleaned_content = 892 chars
payload = 3427 bytes

There was no evidence that the problem stemmed from input length.

Once it was determined that repeatedly requesting GLM was no longer meaningful, I did not choose to modify the historical body to accommodate the model. Instead, I switched to:

Plaintext
ChatGPT generates Chinese excerpt
→ ChatGPT completes English title, excerpt, and body
→ Manually save to WordPress

At the same time, the original:

Plaintext
mark-manual-completed

had excerpt_failed safety support added.

If an article stops at:

Plaintext
excerpt_failed

the program must now additionally confirm:

Plaintext
Chinese excerpt is not empty

and simultaneously check:

Plaintext
post ID
publish
English title
English body
Polylang

Only after truly passing the production read-only checks is it allowed to:

Bash
python3 bin/history-migration.py mark-manual-completed \
    --post-id 文章ID \
    --confirmed

The final article simultaneously preserves:

Plaintext
execution_evidence = excerpt_generation_failed
last_failure = HTTP 400
manual_completion = manual_external
workflow_status = completed

The entire batch ultimately recovered to:

Plaintext
total=20
completed=20
remaining=0

Latest incomplete batch: None
Suggest creating next batch: True
Suggestion: all batches complete

So what was truly solved this time is no longer just:

“What to do when an article gets an HTTP 400?”

It further answered another, more important question:

When an automated model explicitly refuses to process an article, how can the entire automated workflow continue to safely complete the article without tampering with historical evidence, modifying the original text to accommodate the model, or manually faking the state.

The current answer is:

The automated model can fail, but the entire historical article migration workflow must preserve a manual fallback path that is verifiable, auditable, and able to safely converge to completed.

关于作者 · 持续学习与技术实践

我是一名拥有 15 年以上开发经验的技术从业者,自 2013 年起持续运营个人技术博客,记录工作与个人项目中遇到的真实问题,以及解决问题过程中的探索、实践和思考。

除了技术写作,我也在持续开发和维护自己的独立项目,探索新技术和新工具在实际场景中的应用。我始终相信,没有不值得去解决的问题,也没有不值得去学习的技术。

如果这篇文章对你有所帮助,欢迎浏览博客中的其他文章,也欢迎交流技术经验与想法。

关于我  ·  GitHub  ·  邮件联系