Eureka Patent Claim Translated

intent

retrieve translated patent claim text from the eureka patent data platform for one or more patents. use this when a user asks for patent claims in a specific language (chinese, english, japanese), wants to see the legal scope of a patent, needs claim translations, or queries patents by id or publication number. trigger even if the user doesn't explicitly say "translated claims" as long as they're asking for claim content in a specific language or format.

inputs

eureka platform access

• connection: eureka patent data platform via linkfox gateway api
• authentication: api key (set via env var LINKFOX_API_KEY or passed in request headers)
• scope: read access to patent claims database
• setup: contact linkfox support to enable eureka claims endpoint

query parameters

• patentId (string, optional): internal patent id. multiple ids separated by comma. up to 100 per request.
• patentNumber (string, optional): publication/announcement number (e.g., "CN112345678A", "US20210012345A1"). multiple numbers separated by comma. up to 100 per request.
• lang (string, optional): target language. values: en (english, default), cn (chinese), jp (japanese).
• replaceByRelated (integer, optional): fallback to family patent claims if original unavailable. 1 = yes, 0 = no (default).

note: at least one of patentId or patentNumber must be provided. if both are supplied, patentId takes priority.

procedure

1. validate input identifiers

   • input: user request with patent reference (id, publication number, or both)
   • check that at least one of patentId or patentNumber is present
   • output: validation pass or error message ("must provide patentId or patentNumber")

2. normalize patent identifiers

   • input: raw patent references from user
   • split comma-separated values, trim whitespace, convert to uppercase (publication numbers)
   • output: cleaned, standardized identifier list

3. determine target language

   • input: user request (explicit language mention or implicit context)
   • if user specifies chinese/中文 or cn, set lang = "cn"
   • if user specifies japanese/日本語 or jp, set lang = "jp"
   • if user specifies english/英文 or en, or no language mentioned, set lang = "en"
   • output: language code (en, cn, or jp)

4. determine family patent fallback setting

   • input: user request
   • if user explicitly asks to try family patents if claims unavailable, set replaceByRelated = 1
   • otherwise, set replaceByRelated = 0
   • output: fallback flag (0 or 1)

5. split batch if needed

   • input: identifier count
   • if total patents exceeds 100, split into multiple batches of up to 100 each
   • output: batch queue (if count <= 100, single batch; otherwise multiple batches)

6. call eureka claims api

   • input: patentId or patentNumber, lang, replaceByRelated
   • invoke linkfox gateway endpoint with constructed query
   • handle http response codes and network errors
   • output: raw api response (json with total, data[], costToken)

7. parse response data

   • input: api response json
   • extract patent records from data[] array
   • for each record, capture: patentId, pn (publication number), claims (translated text), pnRelated (if family substitution used)
   • output: structured patent claim records

8. format output for display

   • input: parsed patent records, language used, batch count
   • for each patent, display publication number as heading, then claim text
   • if pnRelated is present, add note: "claims sourced from family patent [pnRelated]"
   • add footer: "results in [language name]. total: [count] patents."
   • if multiple batches, show cumulative total
   • output: formatted display string

9. report token consumption

   • input: costToken from api response
   • log or display cost to user (if token tracking enabled)
   • output: token count notification

10. emit outcome signal

    • input: successful response and formatted output
    • confirm to user that claims have been retrieved
    • output: success message visible to user

decision points

if patentId and patentNumber both provided

• use patentId (takes priority over patentNumber)

if neither patentId nor patentNumber provided

• return error: "must provide at least one patent identifier (id or publication number)"
• do not attempt api call

if user specifies language explicitly

• use requested language
• else if language is implicit (e.g., user asks for "中文权利要求")
• infer language from context
• else
• default to english (en)

if user asks for claims and mentions family patent or fallback

• set replaceByRelated = 1
• else
• set replaceByRelated = 0

if api returns empty data array

• message: "no claims found for [patent identifiers]. verify patent ids or publication numbers are correct."
• do not show "0 results" as success
• suggest user check patent number format

if api returns error (auth, rate limit, malformed request)

• auth error: "api key invalid or expired. contact linkfox support."
• rate limit: "too many requests. try again in a few moments or reduce batch size to under 100 patents."
• malformed request: "invalid parameter. verify patentId/patentNumber format and language code."

if patent count exceeds 100

• split into batches of 100, process sequentially
• aggregate results and display total at end
• message: "processing [n] patents in [m] batches..."

if pnRelated is present in response

• this means family patent substitution was applied
• notify user: "claims retrieved from family patent [pnRelated] because original unavailable"

if user asks for analysis, comparison, or abstract/description

• this skill only returns raw claim text, not analysis
• message: "this skill retrieves claim text only. for claim analysis or patent description, use a different tool."

output contract

success response format (json, returned to user or logged)

{
  "total": 3,
  "data": [
    {
      "patentId": "84a1b2c3",
      "pn": "CN112345678A",
      "claims": "1. A method comprising:\n   (a) step one...\n   (b) step two...\n2. The method of claim 1, further comprising...",
      "pnRelated": null
    },
    {
      "patentId": "94c2d3e4",
      "pn": "US20210012345A1",
      "claims": "1. An apparatus having:\n   ...",
      "pnRelated": null
    },
    {
      "patentId": "a4d3e4f5",
      "pn": "EP3456789B1",
      "claims": "1. A system as claimed in claim 1...",
      "pnRelated": "EP3456789A1"
    }
  ],
  "costToken": 45
}

display output (human-readable text to user)

• heading: "patent claims (language: [english/chinese/japanese])"
• for each patent:
  • subheading: publication number
  • body: full claim text
  • note (if applicable): "claims from family patent [pnRelated]"
• footer: "retrieved [total] patent claims. tokens used: [cost]."

file location (if logging enabled)

• logs: logs/eureka_claim_translated_[timestamp].json
• user-facing output: displayed inline in chat or ui

edge cases and error outputs

• empty result: "no claims found. check patent identifiers."
• auth failure: "authentication failed. verify linkfox api key."
• rate limit: "rate limit exceeded. try again later."
• malformed input: "invalid patent id or publication number format."
• network timeout: "request timed out. try again or reduce batch size."
• unsupported language: "language not supported. use en, cn, or jp."

outcome signal

1. visible confirmation: user sees patent claims displayed in requested language with clear labeling of publication number and language type.

2. claim text present: output contains full, readable claim text (not empty, not error message).

3. language correct: returned text is in the language requested (chinese characters for cn, english words for en, kanji/hiragana for jp).

4. total count: if multiple patents queried, user sees accurate total count at end of results.

5. family patent notice (if applicable): when family substitution occurs, user is explicitly told which family patent's claims were returned.

6. token feedback: if token tracking is enabled, user sees token cost reported.

7. no confusion: results clearly distinguish between multiple patents (via publication number headings) and claim boundaries (via claim numbering in text).

8. error clarity: if query fails, user sees actionable error message, not silent failure or timeout.