AI Text Generation

Uses large language models to generate text content based on prompts, supporting combined understanding and analysis of text with images and videos by passing in image and video URLs.

Core Features

Dual Model Options: Fast response (GEM_3_FLASH) and high-quality complex analysis (GEM_3_1_PRO).
Combined Image/Video/Text Content:
```
imageUrls
```
supports both image and video URLs; maximum 10 images, usually 1 video.
Controllable Thinking Depth: 4 levels of thinkingLevel to control reasoning depth.
Asynchronous Two-Step Call: Returns taskId immediately after creating a task, and the client polls for results to avoid long-time synchronous timeout.

Model Description

Model	Description	Applicable Scenarios
GEM_3_FLASH	Fast response (default)	General copywriting, simple analysis, translation
GEM_3_1_PRO	High-quality complex analysis	In-depth analysis, long-form writing, complex reasoning

Thinking Levels

thinkingLevel	Description
minimal	Almost no thinking (not supported by GEM_3_1_PRO)
low	Low thinking depth
medium	Balanced
high	Maximum reasoning depth

Parameter Overview

Required Fields:
```
prompt
```
,
```
imageUrls
```
(pass empty array
```
[]
```
when there are no images or videos),
```
thinkingLevel
```
(must be explicitly passed, default
```
minimal
```
is recommended)
Media URL Convention: Both image and video URLs are passed via
```
imageUrls
```
(e.g., pass
```
["https://example.com/ref.mp4"]
```
for video analysis); do not use undocumented fields (such as
```
videoUrl
```
,
```
videoUrls
```
)

Complete parameter table, response field structure and error codes can be found in

references/api.md

Calling Methods

Adopts asynchronous two-step mode (same as imagegen):

Create Task:
```
POST /aigc/textGenAsync
```
→ Returns
```
taskId
```

Poll for Results:

POST /aigc/textTaskQuery

→ Returns

PROCESSING

SUCCESS

FAILED

Python Scripts (internally encapsulates creation + polling, parameter passing remains the same):
- ```
python scripts/aigc_textgen.py --stdin
```
  — Recommended, reads JSON parameters from stdin to avoid shell escape issues (e.g.,
```
python scripts/aigc_textgen.py --stdin < params.json
```
  )
- ```
python scripts/aigc_textgen.py --stdin --content-only
```
  — Only outputs content text (already a single line)
- ```
python scripts/aigc_textgen.py '<JSON parameters>' [--inline]
```
  — Directly pass parameters for simple scenarios (disabled when prompt contains line breaks)

Polling Strategy: Single HTTP timeout is 150 seconds; polling interval decreases from 10 seconds to 5 seconds; maximum total polling duration is 600 seconds. Complete parameters/responses/error codes can be found in
references/api.md
.

Line Break Flattening is Enabled by Default (no flag required): In all output modes, line breaks in content are automatically replaced with the single character
⏎
(U+23CE), turning the entire content into a single line;
--content-only
only changes "output content text vs complete JSON", and does not affect this flattening behavior.

Output Contract (other agents parse according to this)

Only machine data is placed in stdout, which can always be
json.loads
(exception for
```
--content-only
```
, where stdout is plain text content):
- Default (small result) /
```
--inline
```
  : stdout = complete response JSON
- Large result: stdout = JSON envelope
```
{"ok":bool, "truncated":true, "savedPath":"<path>", "bytes":int, "content":"<single-line text>"}
```
All prompts/summaries/diagnostics (CHAIN-HINT, Saved full response, summarize) go to stderr to avoid polluting stdout.
Exit Code: Success
```
0
```
; Failure (network error /
```
errcode
```
not 200 /
```
status==FAILED
```
) non-0 — agents should prioritize using exit codes to judge errors.

Data Reading Suggestion: For small results, directly use

json.loads(stdout)

to get

content

; for large results, read the

content

from the stdout JSON envelope, or extract complete fields using

jq

according to

savedPath

, to avoid the entire JSON entering the context.

Resolving Authentication and Credit Issues

When the following exceptions occur, guide users to resolve them using references/onboarding.md:

Exception Scenarios

API Key Not Configured: Environment variables
```
LINKFOX_AGENT_API_KEY
```
and
```
LINKFOXAGENT_API_KEY
```
are not configured.
Response with 401 or 402 Status Code
Response Indicates Insufficient Credits or Balance: Message contains "insufficient credit balance/insufficient billing/insufficient balance/quota exceeded/insufficient balance/package expired/need to recharge/please recharge", or similar meanings.

Automatic Chain Call Decision Rules

Agents must follow the following decision tree, and automatically execute upon reading the rules without requiring step-by-step user instructions.

Does the user's subsequent request involve image generation / text-to-image / model replacement / video / imagegen / videogen?
│
├─ YES ──→ Use --content-only mode (line breaks have been flattened to single character ⏎, which can be safely inline concatenated)
│           Capture stdout → inline concatenate into downstream parameter JSON → call downstream Skill
│
└─ NO  ──→ Use default mode
            Small result → json.loads(stdout) to get content
            Large result → read content from stdout JSON envelope, or extract using jq according to savedPath

Line Break Placeholder Convention (Core Mechanism)

content

usually contains real line breaks, which will cause line breaks when directly put into shell variables or concatenated into JSON. The script by default (any mode, no flag required) replaces all line breaks in content with the single character

⏎

(U+23CE), covering both real line break control characters and literal

\n

forms:

```
⏎
```
does not need to be escaped in shell single quotes and JSON strings, turning the entire content into a single line that can be safely captured by variables and inline concatenated;
Downstream AIGC scripts (imagegen / videogen / videogen-multi) will automatically restore
⏎
to line breaks after parsing parameters (via
```
decode_nl_in_obj
```
inline in each AIGC script), so text is transmitted losslessly;
After the entire content becomes a single line, it can be directly captured into a shell variable and inline concatenated into downstream parameter JSON without intermediate files.

Standard Two-Step Chain Call (imagegen / videogen / any AIGC Skill)

bash

# ── Step 1: Generate text, use --content-only to directly get single-line content (line breaks are already ⏎), capture into variable ──────
PROMPT=$(python scripts/aigc_textgen.py --stdin --content-only < textgen_params.json)

# ── Step 2: Inline concatenate into downstream parameters and call downstream Skill (jq handles correct JSON escaping) ───────────
PARAMS=$(jq -nc --arg p "$PROMPT" \
  '{"prompt":$p, "imageUrls":["https://example.com/ref.jpg"], "provider":"BANANA_PRO", "outputNum":1, "resolution":"1K", "aspectRatio":"1:1"}')
python ../linkfox-aigc-imagegen/scripts/aigc_imagegen.py "$PARAMS"
# Downstream script automatically restores ⏎ to line breaks after receiving

Without
jq
, you can directly inline
$PROMPT
into single-quoted JSON: since
⏎
does not need to be escaped and there are no real line breaks, it can also be safely concatenated (provided that content does not contain double quotes; use
jq
first if it does).

Key Parameter Reference for Each Downstream Skill

Downstream Skill	Key Fields (adjust as needed, prompt is injected by upstream)
linkfox-aigc-imagegen	`{"imageUrls":[...],"provider":"BANANA_PRO","outputNum":1,"resolution":"1K","aspectRatio":"1:1"}`
linkfox-aigc-videogen	`{"imageUrls":[...],"model":"WAN2_1","outputNum":1,"resolution":"720P","duration":5}`
linkfox-aigc-imagegen-cloth	`{"imageUrls":[...],"outputNum":1,"aspectRatio":"1:1"}`
linkfox-aigc-imagegen-product	`{"imageUrls":[...],"outputNum":1,"aspectRatio":"1:1"}`

Usage Guidelines

Model Selection: Use
```
GEM_3_FLASH
```
(default, fast response) for simple tasks; use
```
GEM_3_1_PRO
```
for complex analysis and long-form writing.
Prompts: Maximum 100,000 characters; the more specific the description, the better the effect.
Image/Video Input: Pass media URLs via
```
imageUrls
```
. Use
```
[]
```
for plain text; pass 1–10 images for image understanding; usually pass 1 video URL (e.g.,
```
.mp4
```
) for video understanding. For complex video shot/ content analysis, it is recommended to use
```
GEM_3_1_PRO
```
+
```
thinkingLevel: low
```
.
Thinking Level: Choose
```
minimal
```
/
```
low
```
for fast response; choose
```
high
```
for in-depth reasoning.
Video Failure Fallback: If the response indicates the video is unreadable, media access failed,
```
10005
```
or empty content, extract frames into images and pass them into
```
imageUrls
```
(refer to the frame extraction process of downstream business skills).

Examples

1. Basic Text Generation

json

{"prompt": "Write a compelling product description for a wireless bluetooth speaker, highlighting portability and sound quality", "imageUrls": [], "thinkingLevel": "minimal"}

2. Combined Image + Text Analysis

json

{"prompt": "Analyze the composition and selling point expression of this product main image", "imageUrls": ["https://example.com/product-main.jpg"], "model": "GEM_3_1_PRO", "thinkingLevel": "high"}

3. Combined Video + Text Analysis

json

{"prompt": "Analyze the shot rhythm, selling point expression and replicable shot structure of this reference video", "imageUrls": ["https://example.com/reference.mp4"], "model": "GEM_3_1_PRO", "thinkingLevel": "low"}

4. Fast Translation

json

{"prompt": "Translate to German: 'Wireless Bluetooth Speaker with LED Light'", "imageUrls": [], "model": "GEM_3_FLASH", "thinkingLevel": "low"}

Display Rules

Directly display the generated text content.

Limitations

Maximum 100,000 characters for prompts.
Maximum 10 URLs in
```
imageUrls
```
; usually only pass 1 video URL for video analysis, and it is not recommended to mix with image URLs.
```
GEM_3_1_PRO
```
does not support
```
minimal
```
thinking level.
Maximum 3 retries on failure.

Applicable and Inapplicable Scenarios

Applicable:

Product copy/title/five-point description generation
Image content analysis and description
Text translation
Data analysis summary
Video analysis

Inapplicable:

Image generation →
```
linkfox-aigc-imagegen
```
Video generation →
```
linkfox-aigc-videogen
```
Report format output →
```
linkfox-report-generator
```

Feedback

Refer to

references/api.md

linkfox-aigc-textgen

NPX Install

Tags

SKILL.md Content (Chinese)

AI Text Generation

Core Features

Model Description

Thinking Levels

Parameter Overview

Calling Methods

Output Contract (other agents parse according to this)

Resolving Authentication and Credit Issues

Exception Scenarios

Automatic Chain Call Decision Rules

Line Break Placeholder Convention (Core Mechanism)

Standard Two-Step Chain Call (imagegen / videogen / any AIGC Skill)

Key Parameter Reference for Each Downstream Skill

Usage Guidelines

Examples

Display Rules

Limitations

Applicable and Inapplicable Scenarios

Feedback