Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@deepdoc/parser/paddleocr_parser.py`:
- Around line 428-445: The polling loop currently only wraps requests.get(...)
in a try/except but calls poll_resp.json() unconditionally which can raise
JSONDecodeError or leave us with non-2xx HTML responses; update the polling
logic around poll_resp and poll_data to first check poll_resp.status_code (treat
non-2xx as failure and raise RuntimeError with status and body/snippet), catch
JSONDecodeError when calling poll_resp.json() and raise a clear RuntimeError,
and preserve existing handling of poll_data/state and callback; refer to
poll_resp, poll_data, state, requests.get, and the RuntimeError raises when
implementing the checks.

In `@internal/entity/models/paddleocr.go`:
- Around line 205-210: The loop currently blocks on time.After(pollInterval)
before the first poll, delaying initial work; update the polling loop in
paddleocr.go to perform the poll immediately and only sleep between iterations
by moving the time.After wait to the end of the loop (or use a ticker that does
not wait before the first tick). Specifically, adjust the loop that uses ctx,
pollInterval and time.After so the select for ctx.Done() is checked during/after
polling and the time.After(pollInterval) is awaited after completing a poll
iteration instead of before it.

In `@rag/llm/ocr_model.py`:
- Around line 120-124: The resolved paddleocr_base_url can be an empty string
which incorrectly prevents falling back to the legacy key; change the code that
sets self.paddleocr_base_url to treat "" as unset by checking the
_resolve_config result and if it's an empty string, call the legacy fallback
_resolve_config("paddleocr_api_url", "PADDLEOCR_API_URL", "") (or otherwise set
None) before passing it into PaddleOCRParser so the legacy config is respected;
update the assignment around self.paddleocr_base_url and ensure PaddleOCRParser
receives a falsy/None value rather than an empty string.

---

Outside diff comments:
In `@deepdoc/parser/paddleocr_parser.py`:
- Around line 271-294: The method builds config_dict from explicit params but
ignores any caller-supplied **kwargs, so forward those into PaddleOCRConfig by
merging **kwargs into config_dict before calling PaddleOCRConfig.from_dict;
update the block that constructs config_dict to merge kwargs (with kwargs taking
precedence or raise on duplicate keys if desired) and ensure
PaddleOCRConfig.from_dict receives the merged dict (reference symbols:
config_dict, **kwargs, PaddleOCRConfig.from_dict).

In `@internal/entity/models/paddleocr.go`:
- Line 212: The call to http.NewRequestWithContext is ignoring its returned
error; update the code where pollReq, _ := http.NewRequestWithContext(ctx,
"GET", pollUrl, nil) is created (the pollReq variable) to capture the error,
check it, and return or handle it appropriately (e.g., return the error up the
stack or log and exit) so that failures constructing the request are not
silently ignored.

---

Nitpick comments:
In `@deepdoc/parser/paddleocr_parser.py`:
- Around line 375-458: The poll and result-fetch phases currently only use
callback(...) and are not logged when no callback is provided; add explicit
logger.info/debug/error calls in the PaddleOCR flow to mirror the submit log:
log when polling starts for job_id (use poll_url/job_id and variables
interval/deadline), log each significant poll outcome (state values, e.g.,
"poll: state=...", at least when done or failed), and log when fetching the
result and any fetch failures (around the requests.get(result_json_url) and
result_resp.raise_for_status() handling); update the blocks that handle state ==
"done"/"failed", the poll exception handler, and the result fetch exception
handler to call self.logger.info/self.logger.error as appropriate in addition to
the existing callback/raises so operations are visible in service logs.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@deepdoc/parser/paddleocr_parser.py`:
- Around line 413-416: Wrap the unguarded JSON decoding calls so malformed
responses produce the module's RuntimeError with context instead of raw
JSONDecodeError/ValueError: when calling resp.json() before extracting job_id
(variable submit_data), catch JSONDecodeError/ValueError, include resp.text and
the original exception in a RuntimeError message (e.g. "[PaddleOCR] failed to
decode submit response ..."); likewise, when iterating JSONL lines and calling
json.loads(line), wrap each json.loads(line) in a try/except that either raises
a RuntimeError with the offending line/index and original exception or skips the
invalid line after logging, ensuring json parsing failures are converted to
controlled RuntimeError messages and reference the offending line content and
the parsing function (json.loads).
- Line 400: The per-call HTTP timeout currently uses config.request_timeout
which can exceed the remaining end-to-end deadline; compute a per-call timeout
before each network call as max_small = max(0, deadline - time.time()) and then
use per_call_timeout = min(config.request_timeout, max_small) for the
submit/poll/fetch requests (ensure you check deadline/time remaining and
raise/return an appropriate timeout error if per_call_timeout <= 0). Update the
HTTP calls in the submit, polling loop and fetch sections (the submit/poll/fetch
calls in paddleocr_parser.py referenced around the polling loop and lines using
timeout=config.request_timeout) to pass this per_call_timeout instead of
config.request_timeout so each call respects the remaining end-to-end budget.

---

Nitpick comments:
In `@deepdoc/parser/paddleocr_parser.py`:
- Around line 384-409: The code currently writes incoming PDF bytes to a
NamedTemporaryFile (tmp_file) then reopens it to post multipart data; change
submit logic in paddleocr_parser.py (the block creating tmp_file, writing data,
and the requests.post with files={"file": ("document.pdf", f)}) to stream the
bytes directly using an in-memory file-like object (e.g., io.BytesIO or
io.BufferedReader over the bytes) and pass that object to requests.post as the
file value (preserving the filename "document.pdf" and any headers/timeout),
remove the tmp_file creation/cleanup, and keep the existing exception callback
and RuntimeError raising behavior intact.