Puzle Read Skill

Save web articles, documents and files to your personal reading library powered by Puzle.
AI analyzes the full text and enables semantic search across everything you've read.

First-time Setup (show this on skill install)

When this skill is first activated, immediately greet the user and guide them through setup:

1. 1. Check if a token is already configured:

   from puzle_reading import PuzleReadingClient
   if PuzleReadingClient.token_is_configured():
       # Token exists, ready to go
   

If yes, tell the user: "Puzle Read Skill is ready! You can send me any URL, file, or text and I'll save it to your reading library. You can also search across everything you've read."

1. 2. If no token is configured, walk the user through device authorization:

- Tell the user: "To get started, I need to connect to your Puzle account." - Ask the user to open https://read-web.puzle.com.cn/device-auth in their browser and log in - The page will display a device authorization code — ask the user to copy and paste that code back - Once the user provides the code, exchange it for a token:

     PuzleReadingClient.exchange_device_code(code)
     # Token is saved internally — never returned or exposed
     

- Confirm to the user: "Connected to Puzle successfully!"

1. 3. After setup is complete, briefly explain what the skill can do:

- "You can now send me any URL, article, PDF, or text and I'll save it to your Puzle reading library. I can also summarize articles, search across your readings, and more. Just try sending me a link!"

Prerequisites

The bundled Client SDK lives at scripts/puzle_reading.py relative to this skill directory.
It requires the requests library and can be used as a Python library or a standalone CLI tool.

As a Python library:
CODEBLOCK2

As a CLI tool:
CODEBLOCK3

CLI Reference

The SDK doubles as a command-line tool. All data commands output JSON to stdout; errors go to stderr.

CODEBLOCK4

CLI Examples

CODEBLOCK5

Token Management

Token is stored in ~/.config/puzle/config.json with file permission 0o600 (owner read/write only).
The only way to obtain a token is through the device authorization code exchange flow.

Token confidentiality rules:

• - NEVER output, display, log, or echo the JWT token in any form
• NEVER accept a raw JWT token from the user — if a user pastes a JWT (starts with eyJ...),

refuse it and guide them through the device auth flow instead

• - NEVER set the token as an environment variable
• The token is managed exclusively by the SDK internally (_save_token / _load_token are private)

User needs to authorize (no token or token expired)

Guide them through device authorization:

1. 1. Ask the user to open https://read-web.puzle.com.cn/device-auth and log in
2. The page displays a device authorization code — ask the user to paste that code back
3. Exchange the code for a token:

   PuzleReadingClient.exchange_device_code(code)
   # Token is saved internally — never returned or exposed
   client = PuzleReadingClient()  # now auto-loads the saved token
   

1. 4. Confirm: "Connected to Puzle successfully!"

Note: The authorization code is short-lived and single-use — it is safe for users to paste
into the conversation. The actual JWT token never appears in chat history.

Token already configured (most common case)

Once a token has been saved, all subsequent calls work automatically — no need to ask the user again:

CODEBLOCK7

You can check beforehand:

CODEBLOCK8

Token expired (401 error)

The token is valid for approximately 7 days. When you receive PuzleAPIError(code=401):

1. 1. Tell the user their token has expired
2. Guide them through device authorization again (see "User needs to authorize" above)
3. Exchange the new code: INLINECODE8

Two Modes of Use

Mode A: Save for later ("Read It Later")

When the user just wants to save content — no need to wait for processing. Create the reading,
give user the web link, done.

CODEBLOCK9

Use this mode when:

• - "save this" / "bookmark" / "read it later" / "store this link"
• "save all of these" — batch-saving multiple links
• User uploads a file but doesn't ask for any analysis — "just store this PDF"
• User shares a link in passing without asking a question about its content
• "keep it for later"

Mode B: Analyze now (background processing)

When the user wants to understand, summarize, or work with the content, processing takes
30–90 seconds. To avoid blocking the conversation:

1. 1. Create the reading and immediately give user the web link
2. Spawn a background task / subagent to run wait_for_reading() + analysis
3. When the background task completes, present the result to the user

CODEBLOCK10

Why background processing? wait_for_reading() blocks for 30–90 seconds. Running it in
a subagent or background process keeps the conversation responsive. The user gets the web link
instantly and can start reading there, while the analysis runs in parallel.

Use this mode when:

• - "what does this article say" / "summarize this" / "give me a summary"
• "what are the key findings in this PDF" — need to read and analyze
• "compare the viewpoints of these two articles" — need content from multiple readings
• User asks a specific question about the article content
• You need to search across readings afterwards

When to Use Which Method

User shares a URL — Decision Chain

When the user gives you a link, do NOT call create_reading_from_url() directly.
Try the following approaches in order, falling through to the next step only on failure:

CODEBLOCK11

Step 1 readability extraction example:

CODEBLOCK12

When to skip directly to Step 3 (no need to attempt Step 1/2):

• - User explicitly says "let Puzle fetch it" or "use the URL method"
• Batch-saving multiple links (efficiency over quality — no need to fetch each one individually)

User provides content directly — create_reading_from_html()

User says	Example
Pastes raw HTML or article text	"Analyze this content: ..."
Provides pre-fetched page content

"I already scraped this page" | | Content from JS-rendered page | "This page is JS-rendered, here's the source" |

User has a local file — create_reading_from_file()

User says	Example
Uploads or references a local file	"Analyze this PDF" / "Read this report"
Shares meeting notes, memos, private docs

"Here are today's meeting notes, save them" | | Provides pure text to persist | "These are my notes" — save as temp .md first | | Shares images for analysis | "Look at this screenshot" (JPG/PNG) | | Shares audio for transcription | "Process this recording" (MP3/WAV) | | Internal link content already retrieved | Content from Step 1, saved as file then uploaded |

search() — User wants to find something in their readings

User says	Example
Recalls reading something before	"I read an article about microservices before"
Looking for a specific concept

"Is there anything about attention mechanism in my library" | | Cross-referencing topics | "Find everything mentioning transformer" | | Fact-checking against saved readings | "I remember an article said X, find it for me" | | Building on prior knowledge | "What did that paper say again" |

list_readings() — User wants to browse their collection

User says	Example
Checking recent reading history	"What have I read recently" / "Show my reading history"
Looking for a specific reading by title

"What was that article I saved a few days ago" | | Organizing or reviewing collection | "List my readings" |

get_reading_detail() — Need content of a known reading

User says	Example
Wants to re-read a specific article	"Show me the content of reading #42"
Following up on a previous reading

"Show me the full text of that article" | | Checking if processing is complete | (internal use after creating a reading) |

Core Concepts

Concept	Description
Reading	A content record in Puzle — created from a URL, HTML, or file
resource_type

"link" (URL/HTML source) or "file" (uploaded file) | | Status flow | fetching → parsing → ai_reading → done / fail | | Processing | Creating a reading returns immediately; use wait_for_reading() only when you need the full content right away |

Available Methods

All create_reading_* methods return a ReadingResult with a web_url field
(e.g. https://read.puzle.com.cn/read/42) — always share this link with the user.

1. Create reading from URL

CODEBLOCK13

2. Create reading from HTML (pre-fetched content)

Use when the content has already been scraped — skips the fetching phase, so processing is faster.

CODEBLOCK14

3. Create reading from local file

Supported types: PDF, TXT, MD, CSV, JPG, PNG, WebP, GIF, MP3, WAV

CODEBLOCK15

The SDK automatically handles MD5 calculation and S3 upload internally.

If the user provides pure text, private docs, or other text material, you can save them as
a local file and use this method to create a reading.

4. Get reading detail

CODEBLOCK16

Use resource_type="file" for file-based readings. The SDK routes to the correct endpoint.

5. List readings

CODEBLOCK17

Returns a mixed list of link and file readings, sorted by most recent first.

6. Semantic search

CODEBLOCK18

Each result contains: reading_id, reading_title, resource_type, chunk_text, score.

Workflow Examples

Save a link for later (Mode A)

CODEBLOCK19

Batch save multiple links (Mode A)

CODEBLOCK20

Summarize an article (Mode B — background)

CODEBLOCK21

Upload and analyze a local PDF (Mode B — background)

CODEBLOCK22

Save user's text as a reading (Mode A)

When the user provides raw text (notes, memos, etc.), save it as a temp file first:

CODEBLOCK23

Search across all readings

CODEBLOCK24

Find and re-read a past article

CODEBLOCK25

Error Handling

API response format: The Puzle backend always returns HTTP 200. Errors are indicated by the
code field in the JSON body, with the error message in msg:

{"code": 401002, "msg": "Invalid or expired device code", "timestamp": 1775111299}

Success responses have code: 200 and include a data field.

The SDK raises PuzleAPIError with .code and .msg attributes for all API errors.

Error	Meaning	What to do
INLINECODE39	Invalid or expired device code	Ask user to get a new code from /device-auth
INLINECODE40

JWT token expired | Guide user through device auth again at https://read-web.puzle.com.cn/device-auth |
| PuzleAPIError(code=403_003) | Tourist user limit exceeded | Ask user to upgrade their Puzle account |
| PuzleAPIError(code=404_001) | Reading not found | Verify the reading_id is correct |
| PuzleAPIError(code=500) during wait | Processing failed | Tell user the content couldn't be processed |
| PuzleTimeoutError | Processing took >120s | Suggest trying again later; some large files take longer |

Constraints

• - Processing takes 30–90 seconds — only call wait_for_reading() when you need the content (Mode B)
• JWT tokens expire every 7 days — re-authorize via device auth when expired
• File upload link is valid for 1 hour
• INLINECODE46 max is 100 for list_readings

Data Privacy

Uploaded files (PDFs, images, audio, etc.) and web article content are sent to the Puzle service
for processing and storage. Before uploading on behalf of the user, inform them that:

• - Content will be transmitted to and stored by the Puzle service
• Users should not upload sensitive, confidential, or regulated data without verifying the

service's privacy and data retention policies

• - The service URL is hardcoded to https://read-web.puzle.com.cn and cannot be overridden