refactor: marketplace state management (#30702)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

.github/workflows/deploy-agent-dev.yml

@@ -1,4 +1,4 @@
-name: Deploy Trigger Dev
+name: Deploy Agent Dev
 
 permissions:
   contents: read
@@ -7,7 +7,7 @@ on:
   workflow_run:
     workflows: ["Build and Push API & Web"]
     branches:
-      - "deploy/trigger-dev"
+      - "deploy/agent-dev"
     types:
       - completed
 
@@ -16,12 +16,12 @@ jobs:
     runs-on: ubuntu-latest
     if: |
       github.event.workflow_run.conclusion == 'success' &&
-      github.event.workflow_run.head_branch == 'deploy/trigger-dev'
+      github.event.workflow_run.head_branch == 'deploy/agent-dev'
     steps:
       - name: Deploy to server
         uses: appleboy/ssh-action@v0.1.8
         with:
-          host: ${{ secrets.TRIGGER_SSH_HOST }}
+          host: ${{ secrets.AGENT_DEV_SSH_HOST }}
           username: ${{ secrets.SSH_USER }}
           key: ${{ secrets.SSH_PRIVATE_KEY }}
           script: |

.github/workflows/translate-i18n-base-on-english.yml

@@ -1,94 +0,0 @@
-name: Translate i18n Files Based on English
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'web/i18n/en-US/*.json'
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  check-and-update:
-    if: github.repository == 'langgenius/dify'
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: web
-    steps:
-      # Keep use old checkout action version for https://github.com/peter-evans/create-pull-request/issues/4272
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Check for file changes in i18n/en-US
-        id: check_files
-        run: |
-          # Skip check for manual trigger, translate all files
-          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
-            echo "FILES_CHANGED=true" >> $GITHUB_ENV
-            echo "FILE_ARGS=" >> $GITHUB_ENV
-            echo "Manual trigger: translating all files"
-          else
-            git fetch origin "${{ github.event.before }}" || true
-            git fetch origin "${{ github.sha }}" || true
-            changed_files=$(git diff --name-only "${{ github.event.before }}" "${{ github.sha }}" -- 'i18n/en-US/*.json')
-            echo "Changed files: $changed_files"
-            if [ -n "$changed_files" ]; then
-              echo "FILES_CHANGED=true" >> $GITHUB_ENV
-              file_args=""
-              for file in $changed_files; do
-                filename=$(basename "$file" .json)
-                file_args="$file_args --file $filename"
-              done
-              echo "FILE_ARGS=$file_args" >> $GITHUB_ENV
-              echo "File arguments: $file_args"
-            else
-              echo "FILES_CHANGED=false" >> $GITHUB_ENV
-            fi
-          fi
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          package_json_file: web/package.json
-          run_install: false
-
-      - name: Set up Node.js
-        if: env.FILES_CHANGED == 'true'
-        uses: actions/setup-node@v6
-        with:
-          node-version: 'lts/*'
-          cache: pnpm
-          cache-dependency-path: ./web/pnpm-lock.yaml
-
-      - name: Install dependencies
-        if: env.FILES_CHANGED == 'true'
-        working-directory: ./web
-        run: pnpm install --frozen-lockfile
-
-      - name: Generate i18n translations
-        if: env.FILES_CHANGED == 'true'
-        working-directory: ./web
-        run: pnpm run i18n:gen ${{ env.FILE_ARGS }}
-
-      - name: Create Pull Request
-        if: env.FILES_CHANGED == 'true'
-        uses: peter-evans/create-pull-request@v6
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: 'chore(i18n): update translations based on en-US changes'
-          title: 'chore(i18n): translate i18n files based on en-US changes'
-          body: |
-            This PR was automatically created to update i18n translation files based on changes in en-US locale.
-
-            **Triggered by:** ${{ github.sha }}
-
-            **Changes included:**
-            - Updated translation files for all locales
-          branch: chore/automated-i18n-updates-${{ github.sha }}
-          delete-branch: true

.github/workflows/translate-i18n-claude.yml

@@ -0,0 +1,421 @@
+name: Translate i18n Files with Claude Code
+
+# Note: claude-code-action doesn't support push events directly.
+# Push events are handled by trigger-i18n-sync.yml which sends repository_dispatch.
+# See: https://github.com/langgenius/dify/issues/30743
+
+on:
+  repository_dispatch:
+    types: [i18n-sync]
+  workflow_dispatch:
+    inputs:
+      files:
+        description: 'Specific files to translate (space-separated, e.g., "app common"). Leave empty for all files.'
+        required: false
+        type: string
+      languages:
+        description: 'Specific languages to translate (space-separated, e.g., "zh-Hans ja-JP"). Leave empty for all supported languages.'
+        required: false
+        type: string
+      mode:
+        description: 'Sync mode: incremental (only changes) or full (re-check all keys)'
+        required: false
+        default: 'incremental'
+        type: choice
+        options:
+          - incremental
+          - full
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  translate:
+    if: github.repository == 'langgenius/dify'
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Configure Git
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          package_json_file: web/package.json
+          run_install: false
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 'lts/*'
+          cache: pnpm
+          cache-dependency-path: ./web/pnpm-lock.yaml
+
+      - name: Detect changed files and generate diff
+        id: detect_changes
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            # Manual trigger
+            if [ -n "${{ github.event.inputs.files }}" ]; then
+              echo "CHANGED_FILES=${{ github.event.inputs.files }}" >> $GITHUB_OUTPUT
+            else
+              # Get all JSON files in en-US directory
+              files=$(ls web/i18n/en-US/*.json 2>/dev/null | xargs -n1 basename | sed 's/.json$//' | tr '\n' ' ')
+              echo "CHANGED_FILES=$files" >> $GITHUB_OUTPUT
+            fi
+            echo "TARGET_LANGS=${{ github.event.inputs.languages }}" >> $GITHUB_OUTPUT
+            echo "SYNC_MODE=${{ github.event.inputs.mode || 'incremental' }}" >> $GITHUB_OUTPUT
+
+            # For manual trigger with incremental mode, get diff from last commit
+            # For full mode, we'll do a complete check anyway
+            if [ "${{ github.event.inputs.mode }}" == "full" ]; then
+              echo "Full mode: will check all keys" > /tmp/i18n-diff.txt
+              echo "DIFF_AVAILABLE=false" >> $GITHUB_OUTPUT
+            else
+              git diff HEAD~1..HEAD -- 'web/i18n/en-US/*.json' > /tmp/i18n-diff.txt 2>/dev/null || echo "" > /tmp/i18n-diff.txt
+              if [ -s /tmp/i18n-diff.txt ]; then
+                echo "DIFF_AVAILABLE=true" >> $GITHUB_OUTPUT
+              else
+                echo "DIFF_AVAILABLE=false" >> $GITHUB_OUTPUT
+              fi
+            fi
+          elif [ "${{ github.event_name }}" == "repository_dispatch" ]; then
+            # Triggered by push via trigger-i18n-sync.yml workflow
+            # Validate required payload fields
+            if [ -z "${{ github.event.client_payload.changed_files }}" ]; then
+              echo "Error: repository_dispatch payload missing required 'changed_files' field" >&2
+              exit 1
+            fi
+            echo "CHANGED_FILES=${{ github.event.client_payload.changed_files }}" >> $GITHUB_OUTPUT
+            echo "TARGET_LANGS=" >> $GITHUB_OUTPUT
+            echo "SYNC_MODE=${{ github.event.client_payload.sync_mode || 'incremental' }}" >> $GITHUB_OUTPUT
+
+            # Decode the base64-encoded diff from the trigger workflow
+            if [ -n "${{ github.event.client_payload.diff_base64 }}" ]; then
+              if ! echo "${{ github.event.client_payload.diff_base64 }}" | base64 -d > /tmp/i18n-diff.txt 2>&1; then
+                echo "Warning: Failed to decode base64 diff payload" >&2
+                echo "" > /tmp/i18n-diff.txt
+                echo "DIFF_AVAILABLE=false" >> $GITHUB_OUTPUT
+              elif [ -s /tmp/i18n-diff.txt ]; then
+                echo "DIFF_AVAILABLE=true" >> $GITHUB_OUTPUT
+              else
+                echo "DIFF_AVAILABLE=false" >> $GITHUB_OUTPUT
+              fi
+            else
+              echo "" > /tmp/i18n-diff.txt
+              echo "DIFF_AVAILABLE=false" >> $GITHUB_OUTPUT
+            fi
+          else
+            echo "Unsupported event type: ${{ github.event_name }}"
+            exit 1
+          fi
+
+          # Truncate diff if too large (keep first 50KB)
+          if [ -f /tmp/i18n-diff.txt ]; then
+            head -c 50000 /tmp/i18n-diff.txt > /tmp/i18n-diff-truncated.txt
+            mv /tmp/i18n-diff-truncated.txt /tmp/i18n-diff.txt
+          fi
+
+          echo "Detected files: $(cat $GITHUB_OUTPUT | grep CHANGED_FILES || echo 'none')"
+
+      - name: Run Claude Code for Translation Sync
+        if: steps.detect_changes.outputs.CHANGED_FILES != ''
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          prompt: |
+            You are a professional i18n synchronization engineer for the Dify project.
+            Your task is to keep all language translations in sync with the English source (en-US).
+
+            ## CRITICAL TOOL RESTRICTIONS
+            - Use **Read** tool to read files (NOT cat or bash)
+            - Use **Edit** tool to modify JSON files (NOT node, jq, or bash scripts)
+            - Use **Bash** ONLY for: git commands, gh commands, pnpm commands
+            - Run bash commands ONE BY ONE, never combine with && or ||
+            - NEVER use `$()` command substitution - it's not supported. Split into separate commands instead.
+
+            ## WORKING DIRECTORY & ABSOLUTE PATHS
+            Claude Code sandbox working directory may vary. Always use absolute paths:
+            - For pnpm: `pnpm --dir ${{ github.workspace }}/web <command>`
+            - For git: `git -C ${{ github.workspace }} <command>`
+            - For gh: `gh --repo ${{ github.repository }} <command>`
+            - For file paths: `${{ github.workspace }}/web/i18n/`
+
+            ## EFFICIENCY RULES
+            - **ONE Edit per language file** - batch all key additions into a single Edit
+            - Insert new keys at the beginning of JSON (after `{`), lint:fix will sort them
+            - Translate ALL keys for a language mentally first, then do ONE Edit
+
+            ## Context
+            - Changed/target files: ${{ steps.detect_changes.outputs.CHANGED_FILES }}
+            - Target languages (empty means all supported): ${{ steps.detect_changes.outputs.TARGET_LANGS }}
+            - Sync mode: ${{ steps.detect_changes.outputs.SYNC_MODE }}
+            - Translation files are located in: ${{ github.workspace }}/web/i18n/{locale}/{filename}.json
+            - Language configuration is in: ${{ github.workspace }}/web/i18n-config/languages.ts
+            - Git diff is available: ${{ steps.detect_changes.outputs.DIFF_AVAILABLE }}
+
+            ## CRITICAL DESIGN: Verify First, Then Sync
+
+            You MUST follow this three-phase approach:
+
+            ═══════════════════════════════════════════════════════════════
+            ║  PHASE 1: VERIFY - Analyze and Generate Change Report       ║
+            ═══════════════════════════════════════════════════════════════
+
+            ### Step 1.1: Analyze Git Diff (for incremental mode)
+            Use the Read tool to read `/tmp/i18n-diff.txt` to see the git diff.
+
+            Parse the diff to categorize changes:
+            - Lines with `+` (not `+++`): Added or modified values
+            - Lines with `-` (not `---`): Removed or old values
+            - Identify specific keys for each category:
+              * ADD: Keys that appear only in `+` lines (new keys)
+              * UPDATE: Keys that appear in both `-` and `+` lines (value changed)
+              * DELETE: Keys that appear only in `-` lines (removed keys)
+
+            ### Step 1.2: Read Language Configuration
+            Use the Read tool to read `${{ github.workspace }}/web/i18n-config/languages.ts`.
+            Extract all languages with `supported: true`.
+
+            ### Step 1.3: Run i18n:check for Each Language
+            ```bash
+            pnpm --dir ${{ github.workspace }}/web install --frozen-lockfile
+            ```
+            ```bash
+            pnpm --dir ${{ github.workspace }}/web run i18n:check
+            ```
+
+            This will report:
+            - Missing keys (need to ADD)
+            - Extra keys (need to DELETE)
+
+            ### Step 1.4: Generate Change Report
+
+            Create a structured report identifying:
+            ```
+            ╔══════════════════════════════════════════════════════════════╗
+            ║                    I18N SYNC CHANGE REPORT                   ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ Files to process: [list]                                     ║
+            ║ Languages to sync: [list]                                    ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ ADD (New Keys):                                              ║
+            ║   - [filename].[key]: "English value"                        ║
+            ║   ...                                                        ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ UPDATE (Modified Keys - MUST re-translate):                  ║
+            ║   - [filename].[key]: "Old value" → "New value"              ║
+            ║   ...                                                        ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ DELETE (Extra Keys):                                         ║
+            ║   - [language]/[filename].[key]                              ║
+            ║   ...                                                        ║
+            ╚══════════════════════════════════════════════════════════════╝
+            ```
+
+            **IMPORTANT**: For UPDATE detection, compare git diff to find keys where
+            the English value changed. These MUST be re-translated even if target
+            language already has a translation (it's now stale!).
+
+            ═══════════════════════════════════════════════════════════════
+            ║  PHASE 2: SYNC - Execute Changes Based on Report            ║
+            ═══════════════════════════════════════════════════════════════
+
+            ### Step 2.1: Process ADD Operations (BATCH per language file)
+
+            **CRITICAL WORKFLOW for efficiency:**
+            1. First, translate ALL new keys for ALL languages mentally
+            2. Then, for EACH language file, do ONE Edit operation:
+               - Read the file once
+               - Insert ALL new keys at the beginning (right after the opening `{`)
+               - Don't worry about alphabetical order - lint:fix will sort them later
+
+            Example Edit (adding 3 keys to zh-Hans/app.json):
+            ```
+            old_string: '{\n  "accessControl"'
+            new_string: '{\n  "newKey1": "translation1",\n  "newKey2": "translation2",\n  "newKey3": "translation3",\n  "accessControl"'
+            ```
+
+            **IMPORTANT**:
+            - ONE Edit per language file (not one Edit per key!)
+            - Always use the Edit tool. NEVER use bash scripts, node, or jq.
+
+            ### Step 2.2: Process UPDATE Operations
+
+            **IMPORTANT: Special handling for zh-Hans and ja-JP**
+            If zh-Hans or ja-JP files were ALSO modified in the same push:
+            - Run: `git -C ${{ github.workspace }} diff HEAD~1 --name-only` and check for zh-Hans or ja-JP files
+            - If found, it means someone manually translated them. Apply these rules:
+
+            1. **Missing keys**: Still ADD them (completeness required)
+            2. **Existing translations**: Compare with the NEW English value:
+               - If translation is **completely wrong** or **unrelated** → Update it
+               - If translation is **roughly correct** (captures the meaning) → Keep it, respect manual work
+               - When in doubt, **keep the manual translation**
+
+            Example:
+            - English changed: "Save" → "Save Changes"
+            - Manual translation: "保存更改" → Keep it (correct meaning)
+            - Manual translation: "删除" → Update it (completely wrong)
+
+            For other languages:
+            Use Edit tool to replace the old value with the new translation.
+            You can batch multiple updates in one Edit if they are adjacent.
+
+            ### Step 2.3: Process DELETE Operations
+            For extra keys reported by i18n:check:
+            - Run: `pnpm --dir ${{ github.workspace }}/web run i18n:check --auto-remove`
+            - Or manually remove from target language JSON files
+
+            ## Translation Guidelines
+
+            - PRESERVE all placeholders exactly as-is:
+              - `{{variable}}` - Mustache interpolation
+              - `${variable}` - Template literal
+              - `<tag>content</tag>` - HTML tags
+              - `_one`, `_other` - Pluralization suffixes (these are KEY suffixes, not values)
+            - Use appropriate language register (formal/informal) based on existing translations
+            - Match existing translation style in each language
+            - Technical terms: check existing conventions per language
+            - For CJK languages: no spaces between characters unless necessary
+            - For RTL languages (ar-TN, fa-IR): ensure proper text handling
+
+            ## Output Format Requirements
+            - Alphabetical key ordering (if original file uses it)
+            - 2-space indentation
+            - Trailing newline at end of file
+            - Valid JSON (use proper escaping for special characters)
+
+            ═══════════════════════════════════════════════════════════════
+            ║  PHASE 3: RE-VERIFY - Confirm All Issues Resolved           ║
+            ═══════════════════════════════════════════════════════════════
+
+            ### Step 3.1: Run Lint Fix (IMPORTANT!)
+            ```bash
+            pnpm --dir ${{ github.workspace }}/web lint:fix --quiet -- 'i18n/**/*.json'
+            ```
+            This ensures:
+            - JSON keys are sorted alphabetically (jsonc/sort-keys rule)
+            - Valid i18n keys (dify-i18n/valid-i18n-keys rule)
+            - No extra keys (dify-i18n/no-extra-keys rule)
+
+            ### Step 3.2: Run Final i18n Check
+            ```bash
+            pnpm --dir ${{ github.workspace }}/web run i18n:check
+            ```
+
+            ### Step 3.3: Fix Any Remaining Issues
+            If check reports issues:
+            - Go back to PHASE 2 for unresolved items
+            - Repeat until check passes
+
+            ### Step 3.4: Generate Final Summary
+            ```
+            ╔══════════════════════════════════════════════════════════════╗
+            ║                    SYNC COMPLETED SUMMARY                    ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ Language      │ Added │ Updated │ Deleted │ Status          ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ zh-Hans       │  5    │   2     │    1    │ ✓ Complete      ║
+            ║ ja-JP         │  5    │   2     │    1    │ ✓ Complete      ║
+            ║ ...           │ ...   │  ...    │   ...   │ ...             ║
+            ╠══════════════════════════════════════════════════════════════╣
+            ║ i18n:check    │ PASSED - All keys in sync                   ║
+            ╚══════════════════════════════════════════════════════════════╝
+            ```
+
+            ## Mode-Specific Behavior
+
+            **SYNC_MODE = "incremental"** (default):
+            - Focus on keys identified from git diff
+            - Also check i18n:check output for any missing/extra keys
+            - Efficient for small changes
+
+            **SYNC_MODE = "full"**:
+            - Compare ALL keys between en-US and each language
+            - Run i18n:check to identify all discrepancies
+            - Use for first-time sync or fixing historical issues
+
+            ## Important Notes
+
+            1. Always run i18n:check BEFORE and AFTER making changes
+            2. The check script is the source of truth for missing/extra keys
+            3. For UPDATE scenario: git diff is the source of truth for changed values
+            4. Create a single commit with all translation changes
+            5. If any translation fails, continue with others and report failures
+
+            ═══════════════════════════════════════════════════════════════
+            ║  PHASE 4: COMMIT AND CREATE PR                              ║
+            ═══════════════════════════════════════════════════════════════
+
+            After all translations are complete and verified:
+
+            ### Step 4.1: Check for changes
+            ```bash
+            git -C ${{ github.workspace }} status --porcelain
+            ```
+
+            If there are changes:
+
+            ### Step 4.2: Create a new branch and commit
+            Run these git commands ONE BY ONE (not combined with &&).
+            **IMPORTANT**: Do NOT use `$()` command substitution. Use two separate commands:
+
+            1. First, get the timestamp:
+            ```bash
+            date +%Y%m%d-%H%M%S
+            ```
+            (Note the output, e.g., "20260115-143052")
+
+            2. Then create branch using the timestamp value:
+            ```bash
+            git -C ${{ github.workspace }} checkout -b chore/i18n-sync-20260115-143052
+            ```
+            (Replace "20260115-143052" with the actual timestamp from step 1)
+
+            3. Stage changes:
+            ```bash
+            git -C ${{ github.workspace }} add web/i18n/
+            ```
+
+            4. Commit:
+            ```bash
+            git -C ${{ github.workspace }} commit -m "chore(i18n): sync translations with en-US - Mode: ${{ steps.detect_changes.outputs.SYNC_MODE }}"
+            ```
+
+            5. Push:
+            ```bash
+            git -C ${{ github.workspace }} push origin HEAD
+            ```
+
+            ### Step 4.3: Create Pull Request
+            ```bash
+            gh pr create --repo ${{ github.repository }} --title "chore(i18n): sync translations with en-US" --body "## Summary
+
+            This PR was automatically generated to sync i18n translation files.
+
+            ### Changes
+            - Mode: ${{ steps.detect_changes.outputs.SYNC_MODE }}
+            - Files processed: ${{ steps.detect_changes.outputs.CHANGED_FILES }}
+
+            ### Verification
+            - [x] \`i18n:check\` passed
+            - [x] \`lint:fix\` applied
+
+            🤖 Generated with Claude Code GitHub Action" --base main
+            ```
+
+          claude_args: |
+            --max-turns 150
+            --allowedTools "Read,Write,Edit,Bash(git *),Bash(git:*),Bash(gh *),Bash(gh:*),Bash(pnpm *),Bash(pnpm:*),Bash(date *),Bash(date:*),Glob,Grep"

.github/workflows/trigger-i18n-sync.yml

@@ -0,0 +1,66 @@
+name: Trigger i18n Sync on Push
+
+# This workflow bridges the push event to repository_dispatch
+# because claude-code-action doesn't support push events directly.
+# See: https://github.com/langgenius/dify/issues/30743
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'web/i18n/en-US/*.json'
+
+permissions:
+  contents: write
+
+jobs:
+  trigger:
+    if: github.repository == 'langgenius/dify'
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Detect changed files and generate diff
+        id: detect
+        run: |
+          BEFORE_SHA="${{ github.event.before }}"
+          # Handle edge case: force push may have null/zero SHA
+          if [ -z "$BEFORE_SHA" ] || [ "$BEFORE_SHA" = "0000000000000000000000000000000000000000" ]; then
+            BEFORE_SHA="HEAD~1"
+          fi
+
+          # Detect changed i18n files
+          changed=$(git diff --name-only "$BEFORE_SHA" "${{ github.sha }}" -- 'web/i18n/en-US/*.json' 2>/dev/null | xargs -n1 basename 2>/dev/null | sed 's/.json$//' | tr '\n' ' ' || echo "")
+          echo "changed_files=$changed" >> $GITHUB_OUTPUT
+
+          # Generate diff for context
+          git diff "$BEFORE_SHA" "${{ github.sha }}" -- 'web/i18n/en-US/*.json' > /tmp/i18n-diff.txt 2>/dev/null || echo "" > /tmp/i18n-diff.txt
+
+          # Truncate if too large (keep first 50KB to match receiving workflow)
+          head -c 50000 /tmp/i18n-diff.txt > /tmp/i18n-diff-truncated.txt
+          mv /tmp/i18n-diff-truncated.txt /tmp/i18n-diff.txt
+
+          # Base64 encode the diff for safe JSON transport (portable, single-line)
+          diff_base64=$(base64 < /tmp/i18n-diff.txt | tr -d '\n')
+          echo "diff_base64=$diff_base64" >> $GITHUB_OUTPUT
+
+          if [ -n "$changed" ]; then
+            echo "has_changes=true" >> $GITHUB_OUTPUT
+            echo "Detected changed files: $changed"
+          else
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+            echo "No i18n changes detected"
+          fi
+
+      - name: Trigger i18n sync workflow
+        if: steps.detect.outputs.has_changes == 'true'
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          event-type: i18n-sync
+          client-payload: '{"changed_files": "${{ steps.detect.outputs.changed_files }}", "diff_base64": "${{ steps.detect.outputs.diff_base64 }}", "sync_mode": "incremental", "trigger_sha": "${{ github.sha }}"}'

api/configs/feature/hosted_service/__init__.py

@@ -8,6 +8,11 @@ class HostedCreditConfig(BaseSettings):
         default="",
     )
 
+    HOSTED_POOL_CREDITS: int = Field(
+        description="Pool credits for hosted service",
+        default=200,
+    )
+
     def get_model_credits(self, model_name: str) -> int:
         """
         Get credit value for a specific model name.
@@ -60,19 +65,46 @@ class HostedOpenAiConfig(BaseSettings):
 
     HOSTED_OPENAI_TRIAL_MODELS: str = Field(
         description="Comma-separated list of available models for trial access",
-        default="gpt-3.5-turbo,"
-        "gpt-3.5-turbo-1106,"
-        "gpt-3.5-turbo-instruct,"
+        default="gpt-4,"
+        "gpt-4-turbo-preview,"
+        "gpt-4-turbo-2024-04-09,"
+        "gpt-4-1106-preview,"
+        "gpt-4-0125-preview,"
+        "gpt-4-turbo,"
+        "gpt-4.1,"
+        "gpt-4.1-2025-04-14,"
+        "gpt-4.1-mini,"
+        "gpt-4.1-mini-2025-04-14,"
+        "gpt-4.1-nano,"
+        "gpt-4.1-nano-2025-04-14,"
+        "gpt-3.5-turbo,"
         "gpt-3.5-turbo-16k,"
         "gpt-3.5-turbo-16k-0613,"
+        "gpt-3.5-turbo-1106,"
         "gpt-3.5-turbo-0613,"
         "gpt-3.5-turbo-0125,"
-        "text-davinci-003",
-    )
-
-    HOSTED_OPENAI_QUOTA_LIMIT: NonNegativeInt = Field(
-        description="Quota limit for hosted OpenAI service usage",
-        default=200,
+        "gpt-3.5-turbo-instruct,"
+        "text-davinci-003,"
+        "chatgpt-4o-latest,"
+        "gpt-4o,"
+        "gpt-4o-2024-05-13,"
+        "gpt-4o-2024-08-06,"
+        "gpt-4o-2024-11-20,"
+        "gpt-4o-audio-preview,"
+        "gpt-4o-audio-preview-2025-06-03,"
+        "gpt-4o-mini,"
+        "gpt-4o-mini-2024-07-18,"
+        "o3-mini,"
+        "o3-mini-2025-01-31,"
+        "gpt-5-mini-2025-08-07,"
+        "gpt-5-mini,"
+        "o4-mini,"
+        "o4-mini-2025-04-16,"
+        "gpt-5-chat-latest,"
+        "gpt-5,"
+        "gpt-5-2025-08-07,"
+        "gpt-5-nano,"
+        "gpt-5-nano-2025-08-07",
     )
 
     HOSTED_OPENAI_PAID_ENABLED: bool = Field(
@@ -87,6 +119,13 @@ class HostedOpenAiConfig(BaseSettings):
         "gpt-4-turbo-2024-04-09,"
         "gpt-4-1106-preview,"
         "gpt-4-0125-preview,"
+        "gpt-4-turbo,"
+        "gpt-4.1,"
+        "gpt-4.1-2025-04-14,"
+        "gpt-4.1-mini,"
+        "gpt-4.1-mini-2025-04-14,"
+        "gpt-4.1-nano,"
+        "gpt-4.1-nano-2025-04-14,"
         "gpt-3.5-turbo,"
         "gpt-3.5-turbo-16k,"
         "gpt-3.5-turbo-16k-0613,"
@@ -94,7 +133,150 @@ class HostedOpenAiConfig(BaseSettings):
         "gpt-3.5-turbo-0613,"
         "gpt-3.5-turbo-0125,"
         "gpt-3.5-turbo-instruct,"
-        "text-davinci-003",
+        "text-davinci-003,"
+        "chatgpt-4o-latest,"
+        "gpt-4o,"
+        "gpt-4o-2024-05-13,"
+        "gpt-4o-2024-08-06,"
+        "gpt-4o-2024-11-20,"
+        "gpt-4o-audio-preview,"
+        "gpt-4o-audio-preview-2025-06-03,"
+        "gpt-4o-mini,"
+        "gpt-4o-mini-2024-07-18,"
+        "o3-mini,"
+        "o3-mini-2025-01-31,"
+        "gpt-5-mini-2025-08-07,"
+        "gpt-5-mini,"
+        "o4-mini,"
+        "o4-mini-2025-04-16,"
+        "gpt-5-chat-latest,"
+        "gpt-5,"
+        "gpt-5-2025-08-07,"
+        "gpt-5-nano,"
+        "gpt-5-nano-2025-08-07",
+    )
+
+
+class HostedGeminiConfig(BaseSettings):
+    """
+    Configuration for fetching Gemini service
+    """
+
+    HOSTED_GEMINI_API_KEY: str | None = Field(
+        description="API key for hosted Gemini service",
+        default=None,
+    )
+
+    HOSTED_GEMINI_API_BASE: str | None = Field(
+        description="Base URL for hosted Gemini API",
+        default=None,
+    )
+
+    HOSTED_GEMINI_API_ORGANIZATION: str | None = Field(
+        description="Organization ID for hosted Gemini service",
+        default=None,
+    )
+
+    HOSTED_GEMINI_TRIAL_ENABLED: bool = Field(
+        description="Enable trial access to hosted Gemini service",
+        default=False,
+    )
+
+    HOSTED_GEMINI_TRIAL_MODELS: str = Field(
+        description="Comma-separated list of available models for trial access",
+        default="gemini-2.5-flash,gemini-2.0-flash,gemini-2.0-flash-lite,",
+    )
+
+    HOSTED_GEMINI_PAID_ENABLED: bool = Field(
+        description="Enable paid access to hosted gemini service",
+        default=False,
+    )
+
+    HOSTED_GEMINI_PAID_MODELS: str = Field(
+        description="Comma-separated list of available models for paid access",
+        default="gemini-2.5-flash,gemini-2.0-flash,gemini-2.0-flash-lite,",
+    )
+
+
+class HostedXAIConfig(BaseSettings):
+    """
+    Configuration for fetching XAI service
+    """
+
+    HOSTED_XAI_API_KEY: str | None = Field(
+        description="API key for hosted XAI service",
+        default=None,
+    )
+
+    HOSTED_XAI_API_BASE: str | None = Field(
+        description="Base URL for hosted XAI API",
+        default=None,
+    )
+
+    HOSTED_XAI_API_ORGANIZATION: str | None = Field(
+        description="Organization ID for hosted XAI service",
+        default=None,
+    )
+
+    HOSTED_XAI_TRIAL_ENABLED: bool = Field(
+        description="Enable trial access to hosted XAI service",
+        default=False,
+    )
+
+    HOSTED_XAI_TRIAL_MODELS: str = Field(
+        description="Comma-separated list of available models for trial access",
+        default="grok-3,grok-3-mini,grok-3-mini-fast",
+    )
+
+    HOSTED_XAI_PAID_ENABLED: bool = Field(
+        description="Enable paid access to hosted XAI service",
+        default=False,
+    )
+
+    HOSTED_XAI_PAID_MODELS: str = Field(
+        description="Comma-separated list of available models for paid access",
+        default="grok-3,grok-3-mini,grok-3-mini-fast",
+    )
+
+
+class HostedDeepseekConfig(BaseSettings):
+    """
+    Configuration for fetching Deepseek service
+    """
+
+    HOSTED_DEEPSEEK_API_KEY: str | None = Field(
+        description="API key for hosted Deepseek service",
+        default=None,
+    )
+
+    HOSTED_DEEPSEEK_API_BASE: str | None = Field(
+        description="Base URL for hosted Deepseek API",
+        default=None,
+    )
+
+    HOSTED_DEEPSEEK_API_ORGANIZATION: str | None = Field(
+        description="Organization ID for hosted Deepseek service",
+        default=None,
+    )
+
+    HOSTED_DEEPSEEK_TRIAL_ENABLED: bool = Field(
+        description="Enable trial access to hosted Deepseek service",
+        default=False,
+    )
+
+    HOSTED_DEEPSEEK_TRIAL_MODELS: str = Field(
+        description="Comma-separated list of available models for trial access",
+        default="deepseek-chat,deepseek-reasoner",
+    )
+
+    HOSTED_DEEPSEEK_PAID_ENABLED: bool = Field(
+        description="Enable paid access to hosted Deepseek service",
+        default=False,
+    )
+
+    HOSTED_DEEPSEEK_PAID_MODELS: str = Field(
+        description="Comma-separated list of available models for paid access",
+        default="deepseek-chat,deepseek-reasoner",
     )
 
 
@@ -144,16 +326,66 @@ class HostedAnthropicConfig(BaseSettings):
         default=False,
     )
 
-    HOSTED_ANTHROPIC_QUOTA_LIMIT: NonNegativeInt = Field(
-        description="Quota limit for hosted Anthropic service usage",
-        default=600000,
-    )
-
     HOSTED_ANTHROPIC_PAID_ENABLED: bool = Field(
         description="Enable paid access to hosted Anthropic service",
         default=False,
     )
 
+    HOSTED_ANTHROPIC_TRIAL_MODELS: str = Field(
+        description="Comma-separated list of available models for paid access",
+        default="claude-opus-4-20250514,"
+        "claude-sonnet-4-20250514,"
+        "claude-3-5-haiku-20241022,"
+        "claude-3-opus-20240229,"
+        "claude-3-7-sonnet-20250219,"
+        "claude-3-haiku-20240307",
+    )
+    HOSTED_ANTHROPIC_PAID_MODELS: str = Field(
+        description="Comma-separated list of available models for paid access",
+        default="claude-opus-4-20250514,"
+        "claude-sonnet-4-20250514,"
+        "claude-3-5-haiku-20241022,"
+        "claude-3-opus-20240229,"
+        "claude-3-7-sonnet-20250219,"
+        "claude-3-haiku-20240307",
+    )
+
+
+class HostedTongyiConfig(BaseSettings):
+    """
+    Configuration for hosted Tongyi service
+    """
+
+    HOSTED_TONGYI_API_KEY: str | None = Field(
+        description="API key for hosted Tongyi service",
+        default=None,
+    )
+
+    HOSTED_TONGYI_USE_INTERNATIONAL_ENDPOINT: bool = Field(
+        description="Use international endpoint for hosted Tongyi service",
+        default=False,
+    )
+
+    HOSTED_TONGYI_TRIAL_ENABLED: bool = Field(
+        description="Enable trial access to hosted Tongyi service",
+        default=False,
+    )
+
+    HOSTED_TONGYI_PAID_ENABLED: bool = Field(
+        description="Enable paid access to hosted Anthropic service",
+        default=False,
+    )
+
+    HOSTED_TONGYI_TRIAL_MODELS: str = Field(
+        description="Comma-separated list of available models for trial access",
+        default="",
+    )
+
+    HOSTED_TONGYI_PAID_MODELS: str = Field(
+        description="Comma-separated list of available models for paid access",
+        default="",
+    )
+
 
 class HostedMinmaxConfig(BaseSettings):
     """
@@ -246,9 +478,13 @@ class HostedServiceConfig(
     HostedOpenAiConfig,
     HostedSparkConfig,
     HostedZhipuAIConfig,
+    HostedTongyiConfig,
     # moderation
     HostedModerationConfig,
     # credit config
     HostedCreditConfig,
+    HostedGeminiConfig,
+    HostedXAIConfig,
+    HostedDeepseekConfig,
 ):
     pass

api/controllers/console/app/message.py

@@ -202,7 +202,6 @@ message_detail_model = console_ns.model(
         "status": fields.String,
         "error": fields.String,
         "parent_message_id": fields.String,
-        "generation_detail": fields.Raw,
     },
 )
 

api/controllers/console/workspace/trigger_providers.py

@@ -1,14 +1,14 @@
 import logging
-from collections.abc import Mapping
 from typing import Any
 
 from flask import make_response, redirect, request
-from flask_restx import Resource, reqparse
-from pydantic import BaseModel, Field, model_validator
+from flask_restx import Resource
+from pydantic import BaseModel, model_validator
 from sqlalchemy.orm import Session
 from werkzeug.exceptions import BadRequest, Forbidden
 
 from configs import dify_config
+from controllers.common.schema import register_schema_models
 from controllers.web.error import NotFoundError
 from core.model_runtime.utils.encoders import jsonable_encoder
 from core.plugin.entities.plugin_daemon import CredentialType
@@ -35,35 +35,38 @@ from ..wraps import (
 logger = logging.getLogger(__name__)
 
 
-class TriggerSubscriptionUpdateRequest(BaseModel):
-    """Request payload for updating a trigger subscription"""
+class TriggerSubscriptionBuilderCreatePayload(BaseModel):
+    credential_type: str = CredentialType.UNAUTHORIZED
 
-    name: str | None = Field(default=None, description="The name for the subscription")
-    credentials: Mapping[str, Any] | None = Field(default=None, description="The credentials for the subscription")
-    parameters: Mapping[str, Any] | None = Field(default=None, description="The parameters for the subscription")
-    properties: Mapping[str, Any] | None = Field(default=None, description="The properties for the subscription")
+
+class TriggerSubscriptionBuilderVerifyPayload(BaseModel):
+    credentials: dict[str, Any]
+
+
+class TriggerSubscriptionBuilderUpdatePayload(BaseModel):
+    name: str | None = None
+    parameters: dict[str, Any] | None = None
+    properties: dict[str, Any] | None = None
+    credentials: dict[str, Any] | None = None
 
     @model_validator(mode="after")
     def check_at_least_one_field(self):
-        if all(v is None for v in (self.name, self.credentials, self.parameters, self.properties)):
+        if all(v is None for v in self.model_dump().values()):
             raise ValueError("At least one of name, credentials, parameters, or properties must be provided")
         return self
 
 
-class TriggerSubscriptionVerifyRequest(BaseModel):
-    """Request payload for verifying subscription credentials."""
-
-    credentials: Mapping[str, Any] = Field(description="The credentials to verify")
+class TriggerOAuthClientPayload(BaseModel):
+    client_params: dict[str, Any] | None = None
+    enabled: bool | None = None
 
 
-console_ns.schema_model(
-    TriggerSubscriptionUpdateRequest.__name__,
-    TriggerSubscriptionUpdateRequest.model_json_schema(ref_template="#/definitions/{model}"),
-)
-
-console_ns.schema_model(
-    TriggerSubscriptionVerifyRequest.__name__,
-    TriggerSubscriptionVerifyRequest.model_json_schema(ref_template="#/definitions/{model}"),
+register_schema_models(
+    console_ns,
+    TriggerSubscriptionBuilderCreatePayload,
+    TriggerSubscriptionBuilderVerifyPayload,
+    TriggerSubscriptionBuilderUpdatePayload,
+    TriggerOAuthClientPayload,
 )
 
 
@@ -132,16 +135,11 @@ class TriggerSubscriptionListApi(Resource):
             raise
 
 
-parser = reqparse.RequestParser().add_argument(
-    "credential_type", type=str, required=False, nullable=True, location="json"
-)
-
-
 @console_ns.route(
     "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/create",
 )
 class TriggerSubscriptionBuilderCreateApi(Resource):
-    @console_ns.expect(parser)
+    @console_ns.expect(console_ns.models[TriggerSubscriptionBuilderCreatePayload.__name__])
     @setup_required
     @login_required
     @edit_permission_required
@@ -151,10 +149,10 @@ class TriggerSubscriptionBuilderCreateApi(Resource):
         user = current_user
         assert user.current_tenant_id is not None
 
-        args = parser.parse_args()
+        payload = TriggerSubscriptionBuilderCreatePayload.model_validate(console_ns.payload or {})
 
         try:
-            credential_type = CredentialType.of(args.get("credential_type") or CredentialType.UNAUTHORIZED.value)
+            credential_type = CredentialType.of(payload.credential_type)
             subscription_builder = TriggerSubscriptionBuilderService.create_trigger_subscription_builder(
                 tenant_id=user.current_tenant_id,
                 user_id=user.id,
@@ -182,18 +180,11 @@ class TriggerSubscriptionBuilderGetApi(Resource):
         )
 
 
-parser_api = (
-    reqparse.RequestParser()
-    # The credentials of the subscription builder
-    .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
-)
-
-
 @console_ns.route(
     "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/verify-and-update/<path:subscription_builder_id>",
 )
-class TriggerSubscriptionBuilderVerifyAndUpdateApi(Resource):
-    @console_ns.expect(parser_api)
+class TriggerSubscriptionBuilderVerifyApi(Resource):
+    @console_ns.expect(console_ns.models[TriggerSubscriptionBuilderVerifyPayload.__name__])
     @setup_required
     @login_required
     @edit_permission_required
@@ -203,7 +194,7 @@ class TriggerSubscriptionBuilderVerifyAndUpdateApi(Resource):
         user = current_user
         assert user.current_tenant_id is not None
 
-        args = parser_api.parse_args()
+        payload = TriggerSubscriptionBuilderVerifyPayload.model_validate(console_ns.payload or {})
 
         try:
             # Use atomic update_and_verify to prevent race conditions
@@ -213,7 +204,7 @@ class TriggerSubscriptionBuilderVerifyAndUpdateApi(Resource):
                 provider_id=TriggerProviderID(provider),
                 subscription_builder_id=subscription_builder_id,
                 subscription_builder_updater=SubscriptionBuilderUpdater(
-                    credentials=args.get("credentials", None),
+                    credentials=payload.credentials,
                 ),
             )
         except Exception as e:
@@ -221,24 +212,11 @@ class TriggerSubscriptionBuilderVerifyAndUpdateApi(Resource):
             raise ValueError(str(e)) from e
 
 
-parser_update_api = (
-    reqparse.RequestParser()
-    # The name of the subscription builder
-    .add_argument("name", type=str, required=False, nullable=True, location="json")
-    # The parameters of the subscription builder
-    .add_argument("parameters", type=dict, required=False, nullable=True, location="json")
-    # The properties of the subscription builder
-    .add_argument("properties", type=dict, required=False, nullable=True, location="json")
-    # The credentials of the subscription builder
-    .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
-)
-
-
 @console_ns.route(
     "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/update/<path:subscription_builder_id>",
 )
 class TriggerSubscriptionBuilderUpdateApi(Resource):
-    @console_ns.expect(parser_update_api)
+    @console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])
     @setup_required
     @login_required
     @edit_permission_required
@@ -249,7 +227,7 @@ class TriggerSubscriptionBuilderUpdateApi(Resource):
         assert isinstance(user, Account)
         assert user.current_tenant_id is not None
 
-        args = parser_update_api.parse_args()
+        payload = TriggerSubscriptionBuilderUpdatePayload.model_validate(console_ns.payload or {})
         try:
             return jsonable_encoder(
                 TriggerSubscriptionBuilderService.update_trigger_subscription_builder(
@@ -257,10 +235,10 @@ class TriggerSubscriptionBuilderUpdateApi(Resource):
                     provider_id=TriggerProviderID(provider),
                     subscription_builder_id=subscription_builder_id,
                     subscription_builder_updater=SubscriptionBuilderUpdater(
-                        name=args.get("name", None),
-                        parameters=args.get("parameters", None),
-                        properties=args.get("properties", None),
-                        credentials=args.get("credentials", None),
+                        name=payload.name,
+                        parameters=payload.parameters,
+                        properties=payload.properties,
+                        credentials=payload.credentials,
                     ),
                 )
             )
@@ -295,7 +273,7 @@ class TriggerSubscriptionBuilderLogsApi(Resource):
     "/workspaces/current/trigger-provider/<path:provider>/subscriptions/builder/build/<path:subscription_builder_id>",
 )
 class TriggerSubscriptionBuilderBuildApi(Resource):
-    @console_ns.expect(parser_update_api)
+    @console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])
     @setup_required
     @login_required
     @edit_permission_required
@@ -304,7 +282,7 @@ class TriggerSubscriptionBuilderBuildApi(Resource):
         """Build a subscription instance for a trigger provider"""
         user = current_user
         assert user.current_tenant_id is not None
-        args = parser_update_api.parse_args()
+        payload = TriggerSubscriptionBuilderUpdatePayload.model_validate(console_ns.payload or {})
         try:
             # Use atomic update_and_build to prevent race conditions
             TriggerSubscriptionBuilderService.update_and_build_builder(
@@ -313,9 +291,9 @@ class TriggerSubscriptionBuilderBuildApi(Resource):
                 provider_id=TriggerProviderID(provider),
                 subscription_builder_id=subscription_builder_id,
                 subscription_builder_updater=SubscriptionBuilderUpdater(
-                    name=args.get("name", None),
-                    parameters=args.get("parameters", None),
-                    properties=args.get("properties", None),
+                    name=payload.name,
+                    parameters=payload.parameters,
+                    properties=payload.properties,
                 ),
             )
             return 200
@@ -328,7 +306,7 @@ class TriggerSubscriptionBuilderBuildApi(Resource):
     "/workspaces/current/trigger-provider/<path:subscription_id>/subscriptions/update",
 )
 class TriggerSubscriptionUpdateApi(Resource):
-    @console_ns.expect(console_ns.models[TriggerSubscriptionUpdateRequest.__name__])
+    @console_ns.expect(console_ns.models[TriggerSubscriptionBuilderUpdatePayload.__name__])
     @setup_required
     @login_required
     @edit_permission_required
@@ -338,7 +316,7 @@ class TriggerSubscriptionUpdateApi(Resource):
         user = current_user
         assert user.current_tenant_id is not None
 
-        request = TriggerSubscriptionUpdateRequest.model_validate(console_ns.payload)
+        request = TriggerSubscriptionBuilderUpdatePayload.model_validate(console_ns.payload or {})
 
         subscription = TriggerProviderService.get_subscription_by_id(
             tenant_id=user.current_tenant_id,
@@ -568,13 +546,6 @@ class TriggerOAuthCallbackApi(Resource):
         return redirect(f"{dify_config.CONSOLE_WEB_URL}/oauth-callback")
 
 
-parser_oauth_client = (
-    reqparse.RequestParser()
-    .add_argument("client_params", type=dict, required=False, nullable=True, location="json")
-    .add_argument("enabled", type=bool, required=False, nullable=True, location="json")
-)
-
-
 @console_ns.route("/workspaces/current/trigger-provider/<path:provider>/oauth/client")
 class TriggerOAuthClientManageApi(Resource):
     @setup_required
@@ -622,7 +593,7 @@ class TriggerOAuthClientManageApi(Resource):
             logger.exception("Error getting OAuth client", exc_info=e)
             raise
 
-    @console_ns.expect(parser_oauth_client)
+    @console_ns.expect(console_ns.models[TriggerOAuthClientPayload.__name__])
     @setup_required
     @login_required
     @is_admin_or_owner_required
@@ -632,15 +603,15 @@ class TriggerOAuthClientManageApi(Resource):
         user = current_user
         assert user.current_tenant_id is not None
 
-        args = parser_oauth_client.parse_args()
+        payload = TriggerOAuthClientPayload.model_validate(console_ns.payload or {})
 
         try:
             provider_id = TriggerProviderID(provider)
             return TriggerProviderService.save_custom_oauth_client_params(
                 tenant_id=user.current_tenant_id,
                 provider_id=provider_id,
-                client_params=args.get("client_params"),
-                enabled=args.get("enabled"),
+                client_params=payload.client_params,
+                enabled=payload.enabled,
             )
 
         except ValueError as e:
@@ -676,7 +647,7 @@ class TriggerOAuthClientManageApi(Resource):
     "/workspaces/current/trigger-provider/<path:provider>/subscriptions/verify/<path:subscription_id>",
 )
 class TriggerSubscriptionVerifyApi(Resource):
-    @console_ns.expect(console_ns.models[TriggerSubscriptionVerifyRequest.__name__])
+    @console_ns.expect(console_ns.models[TriggerSubscriptionBuilderVerifyPayload.__name__])
     @setup_required
     @login_required
     @edit_permission_required
@@ -686,9 +657,7 @@ class TriggerSubscriptionVerifyApi(Resource):
         user = current_user
         assert user.current_tenant_id is not None
 
-        verify_request: TriggerSubscriptionVerifyRequest = TriggerSubscriptionVerifyRequest.model_validate(
-            console_ns.payload
-        )
+        verify_request = TriggerSubscriptionBuilderVerifyPayload.model_validate(console_ns.payload or {})
 
         try:
             result = TriggerProviderService.verify_subscription_credentials(

api/controllers/console/workspace/workspace.py

@@ -80,6 +80,9 @@ tenant_fields = {
     "in_trial": fields.Boolean,
     "trial_end_reason": fields.String,
     "custom_config": fields.Raw(attribute="custom_config"),
+    "trial_credits": fields.Integer,
+    "trial_credits_used": fields.Integer,
+    "next_credit_reset_date": fields.Integer,
 }
 
 tenants_fields = {

api/controllers/web/login.py

@@ -10,7 +10,12 @@ from controllers.console.auth.error import (
     InvalidEmailError,
 )
 from controllers.console.error import AccountBannedError
-from controllers.console.wraps import only_edition_enterprise, setup_required
+from controllers.console.wraps import (
+    decrypt_code_field,
+    decrypt_password_field,
+    only_edition_enterprise,
+    setup_required,
+)
 from controllers.web import web_ns
 from controllers.web.wraps import decode_jwt_token
 from libs.helper import email
@@ -42,6 +47,7 @@ class LoginApi(Resource):
             404: "Account not found",
         }
     )
+    @decrypt_password_field
     def post(self):
         """Authenticate user and login."""
         parser = (
@@ -181,6 +187,7 @@ class EmailCodeLoginApi(Resource):
             404: "Account not found",
         }
     )
+    @decrypt_code_field
     def post(self):
         parser = (
             reqparse.RequestParser()

api/core/agent/agent_app_runner.py

@@ -1,380 +0,0 @@
-import logging
-from collections.abc import Generator
-from copy import deepcopy
-from typing import Any
-
-from core.agent.base_agent_runner import BaseAgentRunner
-from core.agent.entities import AgentEntity, AgentLog, AgentResult
-from core.agent.patterns.strategy_factory import StrategyFactory
-from core.app.apps.base_app_queue_manager import PublishFrom
-from core.app.entities.queue_entities import QueueAgentThoughtEvent, QueueMessageEndEvent, QueueMessageFileEvent
-from core.file import file_manager
-from core.model_runtime.entities import (
-    AssistantPromptMessage,
-    LLMResult,
-    LLMResultChunk,
-    LLMUsage,
-    PromptMessage,
-    PromptMessageContentType,
-    SystemPromptMessage,
-    TextPromptMessageContent,
-    UserPromptMessage,
-)
-from core.model_runtime.entities.message_entities import ImagePromptMessageContent, PromptMessageContentUnionTypes
-from core.prompt.agent_history_prompt_transform import AgentHistoryPromptTransform
-from core.tools.__base.tool import Tool
-from core.tools.entities.tool_entities import ToolInvokeMeta
-from core.tools.tool_engine import ToolEngine
-from models.model import Message
-
-logger = logging.getLogger(__name__)
-
-
-class AgentAppRunner(BaseAgentRunner):
-    def _create_tool_invoke_hook(self, message: Message):
-        """
-        Create a tool invoke hook that uses ToolEngine.agent_invoke.
-        This hook handles file creation and returns proper meta information.
-        """
-        # Get trace manager from app generate entity
-        trace_manager = self.application_generate_entity.trace_manager
-
-        def tool_invoke_hook(
-            tool: Tool, tool_args: dict[str, Any], tool_name: str
-        ) -> tuple[str, list[str], ToolInvokeMeta]:
-            """Hook that uses agent_invoke for proper file and meta handling."""
-            tool_invoke_response, message_files, tool_invoke_meta = ToolEngine.agent_invoke(
-                tool=tool,
-                tool_parameters=tool_args,
-                user_id=self.user_id,
-                tenant_id=self.tenant_id,
-                message=message,
-                invoke_from=self.application_generate_entity.invoke_from,
-                agent_tool_callback=self.agent_callback,
-                trace_manager=trace_manager,
-                app_id=self.application_generate_entity.app_config.app_id,
-                message_id=message.id,
-                conversation_id=self.conversation.id,
-            )
-
-            # Publish files and track IDs
-            for message_file_id in message_files:
-                self.queue_manager.publish(
-                    QueueMessageFileEvent(message_file_id=message_file_id),
-                    PublishFrom.APPLICATION_MANAGER,
-                )
-                self._current_message_file_ids.append(message_file_id)
-
-            return tool_invoke_response, message_files, tool_invoke_meta
-
-        return tool_invoke_hook
-
-    def run(self, message: Message, query: str, **kwargs: Any) -> Generator[LLMResultChunk, None, None]:
-        """
-        Run Agent application
-        """
-        self.query = query
-        app_generate_entity = self.application_generate_entity
-
-        app_config = self.app_config
-        assert app_config is not None, "app_config is required"
-        assert app_config.agent is not None, "app_config.agent is required"
-
-        # convert tools into ModelRuntime Tool format
-        tool_instances, _ = self._init_prompt_tools()
-
-        assert app_config.agent
-
-        # Create tool invoke hook for agent_invoke
-        tool_invoke_hook = self._create_tool_invoke_hook(message)
-
-        # Get instruction for ReAct strategy
-        instruction = self.app_config.prompt_template.simple_prompt_template or ""
-
-        # Use factory to create appropriate strategy
-        strategy = StrategyFactory.create_strategy(
-            model_features=self.model_features,
-            model_instance=self.model_instance,
-            tools=list(tool_instances.values()),
-            files=list(self.files),
-            max_iterations=app_config.agent.max_iteration,
-            context=self.build_execution_context(),
-            agent_strategy=self.config.strategy,
-            tool_invoke_hook=tool_invoke_hook,
-            instruction=instruction,
-        )
-
-        # Initialize state variables
-        current_agent_thought_id = None
-        has_published_thought = False
-        current_tool_name: str | None = None
-        self._current_message_file_ids: list[str] = []
-
-        # organize prompt messages
-        prompt_messages = self._organize_prompt_messages()
-
-        # Run strategy
-        generator = strategy.run(
-            prompt_messages=prompt_messages,
-            model_parameters=app_generate_entity.model_conf.parameters,
-            stop=app_generate_entity.model_conf.stop,
-            stream=True,
-        )
-
-        # Consume generator and collect result
-        result: AgentResult | None = None
-        try:
-            while True:
-                try:
-                    output = next(generator)
-                except StopIteration as e:
-                    # Generator finished, get the return value
-                    result = e.value
-                    break
-
-                if isinstance(output, LLMResultChunk):
-                    # Handle LLM chunk
-                    if current_agent_thought_id and not has_published_thought:
-                        self.queue_manager.publish(
-                            QueueAgentThoughtEvent(agent_thought_id=current_agent_thought_id),
-                            PublishFrom.APPLICATION_MANAGER,
-                        )
-                        has_published_thought = True
-
-                    yield output
-
-                elif isinstance(output, AgentLog):
-                    # Handle Agent Log using log_type for type-safe dispatch
-                    if output.status == AgentLog.LogStatus.START:
-                        if output.log_type == AgentLog.LogType.ROUND:
-                            # Start of a new round
-                            message_file_ids: list[str] = []
-                            current_agent_thought_id = self.create_agent_thought(
-                                message_id=message.id,
-                                message="",
-                                tool_name="",
-                                tool_input="",
-                                messages_ids=message_file_ids,
-                            )
-                            has_published_thought = False
-
-                        elif output.log_type == AgentLog.LogType.TOOL_CALL:
-                            if current_agent_thought_id is None:
-                                continue
-
-                            # Tool call start - extract data from structured fields
-                            current_tool_name = output.data.get("tool_name", "")
-                            tool_input = output.data.get("tool_args", {})
-
-                            self.save_agent_thought(
-                                agent_thought_id=current_agent_thought_id,
-                                tool_name=current_tool_name,
-                                tool_input=tool_input,
-                                thought=None,
-                                observation=None,
-                                tool_invoke_meta=None,
-                                answer=None,
-                                messages_ids=[],
-                            )
-                            self.queue_manager.publish(
-                                QueueAgentThoughtEvent(agent_thought_id=current_agent_thought_id),
-                                PublishFrom.APPLICATION_MANAGER,
-                            )
-
-                    elif output.status == AgentLog.LogStatus.SUCCESS:
-                        if output.log_type == AgentLog.LogType.THOUGHT:
-                            if current_agent_thought_id is None:
-                                continue
-
-                            thought_text = output.data.get("thought")
-                            self.save_agent_thought(
-                                agent_thought_id=current_agent_thought_id,
-                                tool_name=None,
-                                tool_input=None,
-                                thought=thought_text,
-                                observation=None,
-                                tool_invoke_meta=None,
-                                answer=None,
-                                messages_ids=[],
-                            )
-                            self.queue_manager.publish(
-                                QueueAgentThoughtEvent(agent_thought_id=current_agent_thought_id),
-                                PublishFrom.APPLICATION_MANAGER,
-                            )
-
-                        elif output.log_type == AgentLog.LogType.TOOL_CALL:
-                            if current_agent_thought_id is None:
-                                continue
-
-                            # Tool call finished
-                            tool_output = output.data.get("output")
-                            # Get meta from strategy output (now properly populated)
-                            tool_meta = output.data.get("meta")
-
-                            # Wrap tool_meta with tool_name as key (required by agent_service)
-                            if tool_meta and current_tool_name:
-                                tool_meta = {current_tool_name: tool_meta}
-
-                            self.save_agent_thought(
-                                agent_thought_id=current_agent_thought_id,
-                                tool_name=None,
-                                tool_input=None,
-                                thought=None,
-                                observation=tool_output,
-                                tool_invoke_meta=tool_meta,
-                                answer=None,
-                                messages_ids=self._current_message_file_ids,
-                            )
-                            # Clear message file ids after saving
-                            self._current_message_file_ids = []
-                            current_tool_name = None
-
-                            self.queue_manager.publish(
-                                QueueAgentThoughtEvent(agent_thought_id=current_agent_thought_id),
-                                PublishFrom.APPLICATION_MANAGER,
-                            )
-
-                        elif output.log_type == AgentLog.LogType.ROUND:
-                            if current_agent_thought_id is None:
-                                continue
-
-                            # Round finished - save LLM usage and answer
-                            llm_usage = output.metadata.get(AgentLog.LogMetadata.LLM_USAGE)
-                            llm_result = output.data.get("llm_result")
-                            final_answer = output.data.get("final_answer")
-
-                            self.save_agent_thought(
-                                agent_thought_id=current_agent_thought_id,
-                                tool_name=None,
-                                tool_input=None,
-                                thought=llm_result,
-                                observation=None,
-                                tool_invoke_meta=None,
-                                answer=final_answer,
-                                messages_ids=[],
-                                llm_usage=llm_usage,
-                            )
-                            self.queue_manager.publish(
-                                QueueAgentThoughtEvent(agent_thought_id=current_agent_thought_id),
-                                PublishFrom.APPLICATION_MANAGER,
-                            )
-
-        except Exception:
-            # Re-raise any other exceptions
-            raise
-
-        # Process final result
-        if isinstance(result, AgentResult):
-            final_answer = result.text
-            usage = result.usage or LLMUsage.empty_usage()
-
-            # Publish end event
-            self.queue_manager.publish(
-                QueueMessageEndEvent(
-                    llm_result=LLMResult(
-                        model=self.model_instance.model,
-                        prompt_messages=prompt_messages,
-                        message=AssistantPromptMessage(content=final_answer),
-                        usage=usage,
-                        system_fingerprint="",
-                    )
-                ),
-                PublishFrom.APPLICATION_MANAGER,
-            )
-
-    def _init_system_message(self, prompt_template: str, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
-        """
-        Initialize system message
-        """
-        if not prompt_template:
-            return prompt_messages or []
-
-        prompt_messages = prompt_messages or []
-
-        if prompt_messages and isinstance(prompt_messages[0], SystemPromptMessage):
-            prompt_messages[0] = SystemPromptMessage(content=prompt_template)
-            return prompt_messages
-
-        if not prompt_messages:
-            return [SystemPromptMessage(content=prompt_template)]
-
-        prompt_messages.insert(0, SystemPromptMessage(content=prompt_template))
-        return prompt_messages
-
-    def _organize_user_query(self, query: str, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
-        """
-        Organize user query
-        """
-        if self.files:
-            # get image detail config
-            image_detail_config = (
-                self.application_generate_entity.file_upload_config.image_config.detail
-                if (
-                    self.application_generate_entity.file_upload_config
-                    and self.application_generate_entity.file_upload_config.image_config
-                )
-                else None
-            )
-            image_detail_config = image_detail_config or ImagePromptMessageContent.DETAIL.LOW
-
-            prompt_message_contents: list[PromptMessageContentUnionTypes] = []
-            for file in self.files:
-                prompt_message_contents.append(
-                    file_manager.to_prompt_message_content(
-                        file,
-                        image_detail_config=image_detail_config,
-                    )
-                )
-            prompt_message_contents.append(TextPromptMessageContent(data=query))
-
-            prompt_messages.append(UserPromptMessage(content=prompt_message_contents))
-        else:
-            prompt_messages.append(UserPromptMessage(content=query))
-
-        return prompt_messages
-
-    def _clear_user_prompt_image_messages(self, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
-        """
-        As for now, gpt supports both fc and vision at the first iteration.
-        We need to remove the image messages from the prompt messages at the first iteration.
-        """
-        prompt_messages = deepcopy(prompt_messages)
-
-        for prompt_message in prompt_messages:
-            if isinstance(prompt_message, UserPromptMessage):
-                if isinstance(prompt_message.content, list):
-                    prompt_message.content = "\n".join(
-                        [
-                            content.data
-                            if content.type == PromptMessageContentType.TEXT
-                            else "[image]"
-                            if content.type == PromptMessageContentType.IMAGE
-                            else "[file]"
-                            for content in prompt_message.content
-                        ]
-                    )
-
-        return prompt_messages
-
-    def _organize_prompt_messages(self):
-        # For ReAct strategy, use the agent prompt template
-        if self.config.strategy == AgentEntity.Strategy.CHAIN_OF_THOUGHT and self.config.prompt:
-            prompt_template = self.config.prompt.first_prompt
-        else:
-            prompt_template = self.app_config.prompt_template.simple_prompt_template or ""
-
-        self.history_prompt_messages = self._init_system_message(prompt_template, self.history_prompt_messages)
-        query_prompt_messages = self._organize_user_query(self.query or "", [])
-
-        self.history_prompt_messages = AgentHistoryPromptTransform(
-            model_config=self.model_config,
-            prompt_messages=[*query_prompt_messages, *self._current_thoughts],
-            history_messages=self.history_prompt_messages,
-            memory=self.memory,
-        ).get_prompt()
-
-        prompt_messages = [*self.history_prompt_messages, *query_prompt_messages, *self._current_thoughts]
-        if len(self._current_thoughts) != 0:
-            # clear messages after the first iteration
-            prompt_messages = self._clear_user_prompt_image_messages(prompt_messages)
-        return prompt_messages

api/core/agent/base_agent_runner.py

@@ -5,7 +5,7 @@ from typing import Union, cast
 
 from sqlalchemy import select
 
-from core.agent.entities import AgentEntity, AgentToolEntity, ExecutionContext
+from core.agent.entities import AgentEntity, AgentToolEntity
 from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
 from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
 from core.app.apps.base_app_queue_manager import AppQueueManager
@@ -114,20 +114,9 @@ class BaseAgentRunner(AppRunner):
         features = model_schema.features if model_schema and model_schema.features else []
         self.stream_tool_call = ModelFeature.STREAM_TOOL_CALL in features
         self.files = application_generate_entity.files if ModelFeature.VISION in features else []
-        self.model_features = features
         self.query: str | None = ""
         self._current_thoughts: list[PromptMessage] = []
 
-    def build_execution_context(self) -> ExecutionContext:
-        """Build execution context."""
-        return ExecutionContext(
-            user_id=self.user_id,
-            app_id=self.app_config.app_id,
-            conversation_id=self.conversation.id,
-            message_id=self.message.id,
-            tenant_id=self.tenant_id,
-        )
-
     def _repack_app_generate_entity(
         self, app_generate_entity: AgentChatAppGenerateEntity
     ) -> AgentChatAppGenerateEntity:

api/core/agent/cot_agent_runner.py

@@ -0,0 +1,437 @@
+import json
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Generator, Mapping, Sequence
+from typing import Any
+
+from core.agent.base_agent_runner import BaseAgentRunner
+from core.agent.entities import AgentScratchpadUnit
+from core.agent.output_parser.cot_output_parser import CotAgentOutputParser
+from core.app.apps.base_app_queue_manager import PublishFrom
+from core.app.entities.queue_entities import QueueAgentThoughtEvent, QueueMessageEndEvent, QueueMessageFileEvent
+from core.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsage
+from core.model_runtime.entities.message_entities import (
+    AssistantPromptMessage,
+    PromptMessage,
+    PromptMessageTool,
+    ToolPromptMessage,
+    UserPromptMessage,
+)
+from core.ops.ops_trace_manager import TraceQueueManager
+from core.prompt.agent_history_prompt_transform import AgentHistoryPromptTransform
+from core.tools.__base.tool import Tool
+from core.tools.entities.tool_entities import ToolInvokeMeta
+from core.tools.tool_engine import ToolEngine
+from core.workflow.nodes.agent.exc import AgentMaxIterationError
+from models.model import Message
+
+logger = logging.getLogger(__name__)
+
+
+class CotAgentRunner(BaseAgentRunner, ABC):
+    _is_first_iteration = True
+    _ignore_observation_providers = ["wenxin"]
+    _historic_prompt_messages: list[PromptMessage]
+    _agent_scratchpad: list[AgentScratchpadUnit]
+    _instruction: str
+    _query: str
+    _prompt_messages_tools: Sequence[PromptMessageTool]
+
+    def run(
+        self,
+        message: Message,
+        query: str,
+        inputs: Mapping[str, str],
+    ) -> Generator:
+        """
+        Run Cot agent application
+        """
+
+        app_generate_entity = self.application_generate_entity
+        self._repack_app_generate_entity(app_generate_entity)
+        self._init_react_state(query)
+
+        trace_manager = app_generate_entity.trace_manager
+
+        # check model mode
+        if "Observation" not in app_generate_entity.model_conf.stop:
+            if app_generate_entity.model_conf.provider not in self._ignore_observation_providers:
+                app_generate_entity.model_conf.stop.append("Observation")
+
+        app_config = self.app_config
+        assert app_config.agent
+
+        # init instruction
+        inputs = inputs or {}
+        instruction = app_config.prompt_template.simple_prompt_template or ""
+        self._instruction = self._fill_in_inputs_from_external_data_tools(instruction, inputs)
+
+        iteration_step = 1
+        max_iteration_steps = min(app_config.agent.max_iteration, 99) + 1
+
+        # convert tools into ModelRuntime Tool format
+        tool_instances, prompt_messages_tools = self._init_prompt_tools()
+        self._prompt_messages_tools = prompt_messages_tools
+
+        function_call_state = True
+        llm_usage: dict[str, LLMUsage | None] = {"usage": None}
+        final_answer = ""
+        prompt_messages: list = []  # Initialize prompt_messages
+        agent_thought_id = ""  # Initialize agent_thought_id
+
+        def increase_usage(final_llm_usage_dict: dict[str, LLMUsage | None], usage: LLMUsage):
+            if not final_llm_usage_dict["usage"]:
+                final_llm_usage_dict["usage"] = usage
+            else:
+                llm_usage = final_llm_usage_dict["usage"]
+                llm_usage.prompt_tokens += usage.prompt_tokens
+                llm_usage.completion_tokens += usage.completion_tokens
+                llm_usage.total_tokens += usage.total_tokens
+                llm_usage.prompt_price += usage.prompt_price
+                llm_usage.completion_price += usage.completion_price
+                llm_usage.total_price += usage.total_price
+
+        model_instance = self.model_instance
+
+        while function_call_state and iteration_step <= max_iteration_steps:
+            # continue to run until there is not any tool call
+            function_call_state = False
+
+            if iteration_step == max_iteration_steps:
+                # the last iteration, remove all tools
+                self._prompt_messages_tools = []
+
+            message_file_ids: list[str] = []
+
+            agent_thought_id = self.create_agent_thought(
+                message_id=message.id, message="", tool_name="", tool_input="", messages_ids=message_file_ids
+            )
+
+            if iteration_step > 1:
+                self.queue_manager.publish(
+                    QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                )
+
+            # recalc llm max tokens
+            prompt_messages = self._organize_prompt_messages()
+            self.recalc_llm_max_tokens(self.model_config, prompt_messages)
+            # invoke model
+            chunks = model_instance.invoke_llm(
+                prompt_messages=prompt_messages,
+                model_parameters=app_generate_entity.model_conf.parameters,
+                tools=[],
+                stop=app_generate_entity.model_conf.stop,
+                stream=True,
+                user=self.user_id,
+                callbacks=[],
+            )
+
+            usage_dict: dict[str, LLMUsage | None] = {}
+            react_chunks = CotAgentOutputParser.handle_react_stream_output(chunks, usage_dict)
+            scratchpad = AgentScratchpadUnit(
+                agent_response="",
+                thought="",
+                action_str="",
+                observation="",
+                action=None,
+            )
+
+            # publish agent thought if it's first iteration
+            if iteration_step == 1:
+                self.queue_manager.publish(
+                    QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                )
+
+            for chunk in react_chunks:
+                if isinstance(chunk, AgentScratchpadUnit.Action):
+                    action = chunk
+                    # detect action
+                    assert scratchpad.agent_response is not None
+                    scratchpad.agent_response += json.dumps(chunk.model_dump())
+                    scratchpad.action_str = json.dumps(chunk.model_dump())
+                    scratchpad.action = action
+                else:
+                    assert scratchpad.agent_response is not None
+                    scratchpad.agent_response += chunk
+                    assert scratchpad.thought is not None
+                    scratchpad.thought += chunk
+                    yield LLMResultChunk(
+                        model=self.model_config.model,
+                        prompt_messages=prompt_messages,
+                        system_fingerprint="",
+                        delta=LLMResultChunkDelta(index=0, message=AssistantPromptMessage(content=chunk), usage=None),
+                    )
+
+            assert scratchpad.thought is not None
+            scratchpad.thought = scratchpad.thought.strip() or "I am thinking about how to help you"
+            self._agent_scratchpad.append(scratchpad)
+
+            # Check if max iteration is reached and model still wants to call tools
+            if iteration_step == max_iteration_steps and scratchpad.action:
+                if scratchpad.action.action_name.lower() != "final answer":
+                    raise AgentMaxIterationError(app_config.agent.max_iteration)
+
+            # get llm usage
+            if "usage" in usage_dict:
+                if usage_dict["usage"] is not None:
+                    increase_usage(llm_usage, usage_dict["usage"])
+            else:
+                usage_dict["usage"] = LLMUsage.empty_usage()
+
+            self.save_agent_thought(
+                agent_thought_id=agent_thought_id,
+                tool_name=(scratchpad.action.action_name if scratchpad.action and not scratchpad.is_final() else ""),
+                tool_input={scratchpad.action.action_name: scratchpad.action.action_input} if scratchpad.action else {},
+                tool_invoke_meta={},
+                thought=scratchpad.thought or "",
+                observation="",
+                answer=scratchpad.agent_response or "",
+                messages_ids=[],
+                llm_usage=usage_dict["usage"],
+            )
+
+            if not scratchpad.is_final():
+                self.queue_manager.publish(
+                    QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                )
+
+            if not scratchpad.action:
+                # failed to extract action, return final answer directly
+                final_answer = ""
+            else:
+                if scratchpad.action.action_name.lower() == "final answer":
+                    # action is final answer, return final answer directly
+                    try:
+                        if isinstance(scratchpad.action.action_input, dict):
+                            final_answer = json.dumps(scratchpad.action.action_input, ensure_ascii=False)
+                        elif isinstance(scratchpad.action.action_input, str):
+                            final_answer = scratchpad.action.action_input
+                        else:
+                            final_answer = f"{scratchpad.action.action_input}"
+                    except TypeError:
+                        final_answer = f"{scratchpad.action.action_input}"
+                else:
+                    function_call_state = True
+                    # action is tool call, invoke tool
+                    tool_invoke_response, tool_invoke_meta = self._handle_invoke_action(
+                        action=scratchpad.action,
+                        tool_instances=tool_instances,
+                        message_file_ids=message_file_ids,
+                        trace_manager=trace_manager,
+                    )
+                    scratchpad.observation = tool_invoke_response
+                    scratchpad.agent_response = tool_invoke_response
+
+                    self.save_agent_thought(
+                        agent_thought_id=agent_thought_id,
+                        tool_name=scratchpad.action.action_name,
+                        tool_input={scratchpad.action.action_name: scratchpad.action.action_input},
+                        thought=scratchpad.thought or "",
+                        observation={scratchpad.action.action_name: tool_invoke_response},
+                        tool_invoke_meta={scratchpad.action.action_name: tool_invoke_meta.to_dict()},
+                        answer=scratchpad.agent_response,
+                        messages_ids=message_file_ids,
+                        llm_usage=usage_dict["usage"],
+                    )
+
+                    self.queue_manager.publish(
+                        QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                    )
+
+                # update prompt tool message
+                for prompt_tool in self._prompt_messages_tools:
+                    self.update_prompt_message_tool(tool_instances[prompt_tool.name], prompt_tool)
+
+            iteration_step += 1
+
+        yield LLMResultChunk(
+            model=model_instance.model,
+            prompt_messages=prompt_messages,
+            delta=LLMResultChunkDelta(
+                index=0, message=AssistantPromptMessage(content=final_answer), usage=llm_usage["usage"]
+            ),
+            system_fingerprint="",
+        )
+
+        # save agent thought
+        self.save_agent_thought(
+            agent_thought_id=agent_thought_id,
+            tool_name="",
+            tool_input={},
+            tool_invoke_meta={},
+            thought=final_answer,
+            observation={},
+            answer=final_answer,
+            messages_ids=[],
+        )
+        # publish end event
+        self.queue_manager.publish(
+            QueueMessageEndEvent(
+                llm_result=LLMResult(
+                    model=model_instance.model,
+                    prompt_messages=prompt_messages,
+                    message=AssistantPromptMessage(content=final_answer),
+                    usage=llm_usage["usage"] or LLMUsage.empty_usage(),
+                    system_fingerprint="",
+                )
+            ),
+            PublishFrom.APPLICATION_MANAGER,
+        )
+
+    def _handle_invoke_action(
+        self,
+        action: AgentScratchpadUnit.Action,
+        tool_instances: Mapping[str, Tool],
+        message_file_ids: list[str],
+        trace_manager: TraceQueueManager | None = None,
+    ) -> tuple[str, ToolInvokeMeta]:
+        """
+        handle invoke action
+        :param action: action
+        :param tool_instances: tool instances
+        :param message_file_ids: message file ids
+        :param trace_manager: trace manager
+        :return: observation, meta
+        """
+        # action is tool call, invoke tool
+        tool_call_name = action.action_name
+        tool_call_args = action.action_input
+        tool_instance = tool_instances.get(tool_call_name)
+
+        if not tool_instance:
+            answer = f"there is not a tool named {tool_call_name}"
+            return answer, ToolInvokeMeta.error_instance(answer)
+
+        if isinstance(tool_call_args, str):
+            try:
+                tool_call_args = json.loads(tool_call_args)
+            except json.JSONDecodeError:
+                pass
+
+        # invoke tool
+        tool_invoke_response, message_files, tool_invoke_meta = ToolEngine.agent_invoke(
+            tool=tool_instance,
+            tool_parameters=tool_call_args,
+            user_id=self.user_id,
+            tenant_id=self.tenant_id,
+            message=self.message,
+            invoke_from=self.application_generate_entity.invoke_from,
+            agent_tool_callback=self.agent_callback,
+            trace_manager=trace_manager,
+        )
+
+        # publish files
+        for message_file_id in message_files:
+            # publish message file
+            self.queue_manager.publish(
+                QueueMessageFileEvent(message_file_id=message_file_id), PublishFrom.APPLICATION_MANAGER
+            )
+            # add message file ids
+            message_file_ids.append(message_file_id)
+
+        return tool_invoke_response, tool_invoke_meta
+
+    def _convert_dict_to_action(self, action: dict) -> AgentScratchpadUnit.Action:
+        """
+        convert dict to action
+        """
+        return AgentScratchpadUnit.Action(action_name=action["action"], action_input=action["action_input"])
+
+    def _fill_in_inputs_from_external_data_tools(self, instruction: str, inputs: Mapping[str, Any]) -> str:
+        """
+        fill in inputs from external data tools
+        """
+        for key, value in inputs.items():
+            try:
+                instruction = instruction.replace(f"{{{{{key}}}}}", str(value))
+            except Exception:
+                continue
+
+        return instruction
+
+    def _init_react_state(self, query):
+        """
+        init agent scratchpad
+        """
+        self._query = query
+        self._agent_scratchpad = []
+        self._historic_prompt_messages = self._organize_historic_prompt_messages()
+
+    @abstractmethod
+    def _organize_prompt_messages(self) -> list[PromptMessage]:
+        """
+        organize prompt messages
+        """
+
+    def _format_assistant_message(self, agent_scratchpad: list[AgentScratchpadUnit]) -> str:
+        """
+        format assistant message
+        """
+        message = ""
+        for scratchpad in agent_scratchpad:
+            if scratchpad.is_final():
+                message += f"Final Answer: {scratchpad.agent_response}"
+            else:
+                message += f"Thought: {scratchpad.thought}\n\n"
+                if scratchpad.action_str:
+                    message += f"Action: {scratchpad.action_str}\n\n"
+                if scratchpad.observation:
+                    message += f"Observation: {scratchpad.observation}\n\n"
+
+        return message
+
+    def _organize_historic_prompt_messages(
+        self, current_session_messages: list[PromptMessage] | None = None
+    ) -> list[PromptMessage]:
+        """
+        organize historic prompt messages
+        """
+        result: list[PromptMessage] = []
+        scratchpads: list[AgentScratchpadUnit] = []
+        current_scratchpad: AgentScratchpadUnit | None = None
+
+        for message in self.history_prompt_messages:
+            if isinstance(message, AssistantPromptMessage):
+                if not current_scratchpad:
+                    assert isinstance(message.content, str)
+                    current_scratchpad = AgentScratchpadUnit(
+                        agent_response=message.content,
+                        thought=message.content or "I am thinking about how to help you",
+                        action_str="",
+                        action=None,
+                        observation=None,
+                    )
+                    scratchpads.append(current_scratchpad)
+                if message.tool_calls:
+                    try:
+                        current_scratchpad.action = AgentScratchpadUnit.Action(
+                            action_name=message.tool_calls[0].function.name,
+                            action_input=json.loads(message.tool_calls[0].function.arguments),
+                        )
+                        current_scratchpad.action_str = json.dumps(current_scratchpad.action.to_dict())
+                    except Exception:
+                        logger.exception("Failed to parse tool call from assistant message")
+            elif isinstance(message, ToolPromptMessage):
+                if current_scratchpad:
+                    assert isinstance(message.content, str)
+                    current_scratchpad.observation = message.content
+                else:
+                    raise NotImplementedError("expected str type")
+            elif isinstance(message, UserPromptMessage):
+                if scratchpads:
+                    result.append(AssistantPromptMessage(content=self._format_assistant_message(scratchpads)))
+                    scratchpads = []
+                    current_scratchpad = None
+
+                result.append(message)
+
+        if scratchpads:
+            result.append(AssistantPromptMessage(content=self._format_assistant_message(scratchpads)))
+
+        historic_prompts = AgentHistoryPromptTransform(
+            model_config=self.model_config,
+            prompt_messages=current_session_messages or [],
+            history_messages=result,
+            memory=self.memory,
+        ).get_prompt()
+        return historic_prompts

api/core/agent/cot_chat_agent_runner.py

@@ -0,0 +1,118 @@
+import json
+
+from core.agent.cot_agent_runner import CotAgentRunner
+from core.file import file_manager
+from core.model_runtime.entities import (
+    AssistantPromptMessage,
+    PromptMessage,
+    SystemPromptMessage,
+    TextPromptMessageContent,
+    UserPromptMessage,
+)
+from core.model_runtime.entities.message_entities import ImagePromptMessageContent, PromptMessageContentUnionTypes
+from core.model_runtime.utils.encoders import jsonable_encoder
+
+
+class CotChatAgentRunner(CotAgentRunner):
+    def _organize_system_prompt(self) -> SystemPromptMessage:
+        """
+        Organize system prompt
+        """
+        assert self.app_config.agent
+        assert self.app_config.agent.prompt
+
+        prompt_entity = self.app_config.agent.prompt
+        if not prompt_entity:
+            raise ValueError("Agent prompt configuration is not set")
+        first_prompt = prompt_entity.first_prompt
+
+        system_prompt = (
+            first_prompt.replace("{{instruction}}", self._instruction)
+            .replace("{{tools}}", json.dumps(jsonable_encoder(self._prompt_messages_tools)))
+            .replace("{{tool_names}}", ", ".join([tool.name for tool in self._prompt_messages_tools]))
+        )
+
+        return SystemPromptMessage(content=system_prompt)
+
+    def _organize_user_query(self, query, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
+        """
+        Organize user query
+        """
+        if self.files:
+            # get image detail config
+            image_detail_config = (
+                self.application_generate_entity.file_upload_config.image_config.detail
+                if (
+                    self.application_generate_entity.file_upload_config
+                    and self.application_generate_entity.file_upload_config.image_config
+                )
+                else None
+            )
+            image_detail_config = image_detail_config or ImagePromptMessageContent.DETAIL.LOW
+
+            prompt_message_contents: list[PromptMessageContentUnionTypes] = []
+            for file in self.files:
+                prompt_message_contents.append(
+                    file_manager.to_prompt_message_content(
+                        file,
+                        image_detail_config=image_detail_config,
+                    )
+                )
+            prompt_message_contents.append(TextPromptMessageContent(data=query))
+
+            prompt_messages.append(UserPromptMessage(content=prompt_message_contents))
+        else:
+            prompt_messages.append(UserPromptMessage(content=query))
+
+        return prompt_messages
+
+    def _organize_prompt_messages(self) -> list[PromptMessage]:
+        """
+        Organize
+        """
+        # organize system prompt
+        system_message = self._organize_system_prompt()
+
+        # organize current assistant messages
+        agent_scratchpad = self._agent_scratchpad
+        if not agent_scratchpad:
+            assistant_messages = []
+        else:
+            assistant_message = AssistantPromptMessage(content="")
+            assistant_message.content = ""  # FIXME: type check tell mypy that assistant_message.content is str
+            for unit in agent_scratchpad:
+                if unit.is_final():
+                    assert isinstance(assistant_message.content, str)
+                    assistant_message.content += f"Final Answer: {unit.agent_response}"
+                else:
+                    assert isinstance(assistant_message.content, str)
+                    assistant_message.content += f"Thought: {unit.thought}\n\n"
+                    if unit.action_str:
+                        assistant_message.content += f"Action: {unit.action_str}\n\n"
+                    if unit.observation:
+                        assistant_message.content += f"Observation: {unit.observation}\n\n"
+
+            assistant_messages = [assistant_message]
+
+        # query messages
+        query_messages = self._organize_user_query(self._query, [])
+
+        if assistant_messages:
+            # organize historic prompt messages
+            historic_messages = self._organize_historic_prompt_messages(
+                [system_message, *query_messages, *assistant_messages, UserPromptMessage(content="continue")]
+            )
+            messages = [
+                system_message,
+                *historic_messages,
+                *query_messages,
+                *assistant_messages,
+                UserPromptMessage(content="continue"),
+            ]
+        else:
+            # organize historic prompt messages
+            historic_messages = self._organize_historic_prompt_messages([system_message, *query_messages])
+            messages = [system_message, *historic_messages, *query_messages]
+
+        # join all messages
+        return messages

api/core/agent/cot_completion_agent_runner.py

@@ -0,0 +1,87 @@
+import json
+
+from core.agent.cot_agent_runner import CotAgentRunner
+from core.model_runtime.entities.message_entities import (
+    AssistantPromptMessage,
+    PromptMessage,
+    TextPromptMessageContent,
+    UserPromptMessage,
+)
+from core.model_runtime.utils.encoders import jsonable_encoder
+
+
+class CotCompletionAgentRunner(CotAgentRunner):
+    def _organize_instruction_prompt(self) -> str:
+        """
+        Organize instruction prompt
+        """
+        if self.app_config.agent is None:
+            raise ValueError("Agent configuration is not set")
+        prompt_entity = self.app_config.agent.prompt
+        if prompt_entity is None:
+            raise ValueError("prompt entity is not set")
+        first_prompt = prompt_entity.first_prompt
+
+        system_prompt = (
+            first_prompt.replace("{{instruction}}", self._instruction)
+            .replace("{{tools}}", json.dumps(jsonable_encoder(self._prompt_messages_tools)))
+            .replace("{{tool_names}}", ", ".join([tool.name for tool in self._prompt_messages_tools]))
+        )
+
+        return system_prompt
+
+    def _organize_historic_prompt(self, current_session_messages: list[PromptMessage] | None = None) -> str:
+        """
+        Organize historic prompt
+        """
+        historic_prompt_messages = self._organize_historic_prompt_messages(current_session_messages)
+        historic_prompt = ""
+
+        for message in historic_prompt_messages:
+            if isinstance(message, UserPromptMessage):
+                historic_prompt += f"Question: {message.content}\n\n"
+            elif isinstance(message, AssistantPromptMessage):
+                if isinstance(message.content, str):
+                    historic_prompt += message.content + "\n\n"
+                elif isinstance(message.content, list):
+                    for content in message.content:
+                        if not isinstance(content, TextPromptMessageContent):
+                            continue
+                        historic_prompt += content.data
+
+        return historic_prompt
+
+    def _organize_prompt_messages(self) -> list[PromptMessage]:
+        """
+        Organize prompt messages
+        """
+        # organize system prompt
+        system_prompt = self._organize_instruction_prompt()
+
+        # organize historic prompt messages
+        historic_prompt = self._organize_historic_prompt()
+
+        # organize current assistant messages
+        agent_scratchpad = self._agent_scratchpad
+        assistant_prompt = ""
+        for unit in agent_scratchpad or []:
+            if unit.is_final():
+                assistant_prompt += f"Final Answer: {unit.agent_response}"
+            else:
+                assistant_prompt += f"Thought: {unit.thought}\n\n"
+                if unit.action_str:
+                    assistant_prompt += f"Action: {unit.action_str}\n\n"
+                if unit.observation:
+                    assistant_prompt += f"Observation: {unit.observation}\n\n"
+
+        # query messages
+        query_prompt = f"Question: {self._query}"
+
+        # join all messages
+        prompt = (
+            system_prompt.replace("{{historic_messages}}", historic_prompt)
+            .replace("{{agent_scratchpad}}", assistant_prompt)
+            .replace("{{query}}", query_prompt)
+        )
+
+        return [UserPromptMessage(content=prompt)]

api/core/agent/entities.py

@@ -1,5 +1,3 @@
-import uuid
-from collections.abc import Mapping
 from enum import StrEnum
 from typing import Any, Union
 
@@ -94,96 +92,3 @@ class AgentInvokeMessage(ToolInvokeMessage):
     """
 
     pass
-
-
-class ExecutionContext(BaseModel):
-    """Execution context containing trace and audit information.
-
-    This context carries all the IDs and metadata that are not part of
-    the core business logic but needed for tracing, auditing, and
-    correlation purposes.
-    """
-
-    user_id: str | None = None
-    app_id: str | None = None
-    conversation_id: str | None = None
-    message_id: str | None = None
-    tenant_id: str | None = None
-
-    @classmethod
-    def create_minimal(cls, user_id: str | None = None) -> "ExecutionContext":
-        """Create a minimal context with only essential fields."""
-        return cls(user_id=user_id)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for passing to legacy code."""
-        return {
-            "user_id": self.user_id,
-            "app_id": self.app_id,
-            "conversation_id": self.conversation_id,
-            "message_id": self.message_id,
-            "tenant_id": self.tenant_id,
-        }
-
-    def with_updates(self, **kwargs) -> "ExecutionContext":
-        """Create a new context with updated fields."""
-        data = self.to_dict()
-        data.update(kwargs)
-
-        return ExecutionContext(
-            user_id=data.get("user_id"),
-            app_id=data.get("app_id"),
-            conversation_id=data.get("conversation_id"),
-            message_id=data.get("message_id"),
-            tenant_id=data.get("tenant_id"),
-        )
-
-
-class AgentLog(BaseModel):
-    """
-    Agent Log.
-    """
-
-    class LogType(StrEnum):
-        """Type of agent log entry."""
-
-        ROUND = "round"  # A complete iteration round
-        THOUGHT = "thought"  # LLM thinking/reasoning
-        TOOL_CALL = "tool_call"  # Tool invocation
-
-    class LogMetadata(StrEnum):
-        STARTED_AT = "started_at"
-        FINISHED_AT = "finished_at"
-        ELAPSED_TIME = "elapsed_time"
-        TOTAL_PRICE = "total_price"
-        TOTAL_TOKENS = "total_tokens"
-        PROVIDER = "provider"
-        CURRENCY = "currency"
-        LLM_USAGE = "llm_usage"
-        ICON = "icon"
-        ICON_DARK = "icon_dark"
-
-    class LogStatus(StrEnum):
-        START = "start"
-        ERROR = "error"
-        SUCCESS = "success"
-
-    id: str = Field(default_factory=lambda: str(uuid.uuid4()), description="The id of the log")
-    label: str = Field(..., description="The label of the log")
-    log_type: LogType = Field(..., description="The type of the log")
-    parent_id: str | None = Field(default=None, description="Leave empty for root log")
-    error: str | None = Field(default=None, description="The error message")
-    status: LogStatus = Field(..., description="The status of the log")
-    data: Mapping[str, Any] = Field(..., description="Detailed log data")
-    metadata: Mapping[LogMetadata, Any] = Field(default={}, description="The metadata of the log")
-
-
-class AgentResult(BaseModel):
-    """
-    Agent execution result.
-    """
-
-    text: str = Field(default="", description="The generated text")
-    files: list[Any] = Field(default_factory=list, description="Files produced during execution")
-    usage: Any | None = Field(default=None, description="LLM usage statistics")
-    finish_reason: str | None = Field(default=None, description="Reason for completion")

api/core/agent/fc_agent_runner.py

@@ -0,0 +1,470 @@
+import json
+import logging
+from collections.abc import Generator
+from copy import deepcopy
+from typing import Any, Union
+
+from core.agent.base_agent_runner import BaseAgentRunner
+from core.app.apps.base_app_queue_manager import PublishFrom
+from core.app.entities.queue_entities import QueueAgentThoughtEvent, QueueMessageEndEvent, QueueMessageFileEvent
+from core.file import file_manager
+from core.model_runtime.entities import (
+    AssistantPromptMessage,
+    LLMResult,
+    LLMResultChunk,
+    LLMResultChunkDelta,
+    LLMUsage,
+    PromptMessage,
+    PromptMessageContentType,
+    SystemPromptMessage,
+    TextPromptMessageContent,
+    ToolPromptMessage,
+    UserPromptMessage,
+)
+from core.model_runtime.entities.message_entities import ImagePromptMessageContent, PromptMessageContentUnionTypes
+from core.prompt.agent_history_prompt_transform import AgentHistoryPromptTransform
+from core.tools.entities.tool_entities import ToolInvokeMeta
+from core.tools.tool_engine import ToolEngine
+from core.workflow.nodes.agent.exc import AgentMaxIterationError
+from models.model import Message
+
+logger = logging.getLogger(__name__)
+
+
+class FunctionCallAgentRunner(BaseAgentRunner):
+    def run(self, message: Message, query: str, **kwargs: Any) -> Generator[LLMResultChunk, None, None]:
+        """
+        Run FunctionCall agent application
+        """
+        self.query = query
+        app_generate_entity = self.application_generate_entity
+
+        app_config = self.app_config
+        assert app_config is not None, "app_config is required"
+        assert app_config.agent is not None, "app_config.agent is required"
+
+        # convert tools into ModelRuntime Tool format
+        tool_instances, prompt_messages_tools = self._init_prompt_tools()
+
+        assert app_config.agent
+
+        iteration_step = 1
+        max_iteration_steps = min(app_config.agent.max_iteration, 99) + 1
+
+        # continue to run until there is not any tool call
+        function_call_state = True
+        llm_usage: dict[str, LLMUsage | None] = {"usage": None}
+        final_answer = ""
+        prompt_messages: list = []  # Initialize prompt_messages
+
+        # get tracing instance
+        trace_manager = app_generate_entity.trace_manager
+
+        def increase_usage(final_llm_usage_dict: dict[str, LLMUsage | None], usage: LLMUsage):
+            if not final_llm_usage_dict["usage"]:
+                final_llm_usage_dict["usage"] = usage
+            else:
+                llm_usage = final_llm_usage_dict["usage"]
+                llm_usage.prompt_tokens += usage.prompt_tokens
+                llm_usage.completion_tokens += usage.completion_tokens
+                llm_usage.total_tokens += usage.total_tokens
+                llm_usage.prompt_price += usage.prompt_price
+                llm_usage.completion_price += usage.completion_price
+                llm_usage.total_price += usage.total_price
+
+        model_instance = self.model_instance
+
+        while function_call_state and iteration_step <= max_iteration_steps:
+            function_call_state = False
+
+            if iteration_step == max_iteration_steps:
+                # the last iteration, remove all tools
+                prompt_messages_tools = []
+
+            message_file_ids: list[str] = []
+            agent_thought_id = self.create_agent_thought(
+                message_id=message.id, message="", tool_name="", tool_input="", messages_ids=message_file_ids
+            )
+
+            # recalc llm max tokens
+            prompt_messages = self._organize_prompt_messages()
+            self.recalc_llm_max_tokens(self.model_config, prompt_messages)
+            # invoke model
+            chunks: Union[Generator[LLMResultChunk, None, None], LLMResult] = model_instance.invoke_llm(
+                prompt_messages=prompt_messages,
+                model_parameters=app_generate_entity.model_conf.parameters,
+                tools=prompt_messages_tools,
+                stop=app_generate_entity.model_conf.stop,
+                stream=self.stream_tool_call,
+                user=self.user_id,
+                callbacks=[],
+            )
+
+            tool_calls: list[tuple[str, str, dict[str, Any]]] = []
+
+            # save full response
+            response = ""
+
+            # save tool call names and inputs
+            tool_call_names = ""
+            tool_call_inputs = ""
+
+            current_llm_usage = None
+
+            if isinstance(chunks, Generator):
+                is_first_chunk = True
+                for chunk in chunks:
+                    if is_first_chunk:
+                        self.queue_manager.publish(
+                            QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                        )
+                        is_first_chunk = False
+                    # check if there is any tool call
+                    if self.check_tool_calls(chunk):
+                        function_call_state = True
+                        tool_calls.extend(self.extract_tool_calls(chunk) or [])
+                        tool_call_names = ";".join([tool_call[1] for tool_call in tool_calls])
+                        try:
+                            tool_call_inputs = json.dumps(
+                                {tool_call[1]: tool_call[2] for tool_call in tool_calls}, ensure_ascii=False
+                            )
+                        except TypeError:
+                            # fallback: force ASCII to handle non-serializable objects
+                            tool_call_inputs = json.dumps({tool_call[1]: tool_call[2] for tool_call in tool_calls})
+
+                    if chunk.delta.message and chunk.delta.message.content:
+                        if isinstance(chunk.delta.message.content, list):
+                            for content in chunk.delta.message.content:
+                                response += content.data
+                        else:
+                            response += str(chunk.delta.message.content)
+
+                    if chunk.delta.usage:
+                        increase_usage(llm_usage, chunk.delta.usage)
+                        current_llm_usage = chunk.delta.usage
+
+                    yield chunk
+            else:
+                result = chunks
+                # check if there is any tool call
+                if self.check_blocking_tool_calls(result):
+                    function_call_state = True
+                    tool_calls.extend(self.extract_blocking_tool_calls(result) or [])
+                    tool_call_names = ";".join([tool_call[1] for tool_call in tool_calls])
+                    try:
+                        tool_call_inputs = json.dumps(
+                            {tool_call[1]: tool_call[2] for tool_call in tool_calls}, ensure_ascii=False
+                        )
+                    except TypeError:
+                        # fallback: force ASCII to handle non-serializable objects
+                        tool_call_inputs = json.dumps({tool_call[1]: tool_call[2] for tool_call in tool_calls})
+
+                if result.usage:
+                    increase_usage(llm_usage, result.usage)
+                    current_llm_usage = result.usage
+
+                if result.message and result.message.content:
+                    if isinstance(result.message.content, list):
+                        for content in result.message.content:
+                            response += content.data
+                    else:
+                        response += str(result.message.content)
+
+                if not result.message.content:
+                    result.message.content = ""
+
+                self.queue_manager.publish(
+                    QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                )
+
+                yield LLMResultChunk(
+                    model=model_instance.model,
+                    prompt_messages=result.prompt_messages,
+                    system_fingerprint=result.system_fingerprint,
+                    delta=LLMResultChunkDelta(
+                        index=0,
+                        message=result.message,
+                        usage=result.usage,
+                    ),
+                )
+
+            assistant_message = AssistantPromptMessage(content="", tool_calls=[])
+            if tool_calls:
+                assistant_message.tool_calls = [
+                    AssistantPromptMessage.ToolCall(
+                        id=tool_call[0],
+                        type="function",
+                        function=AssistantPromptMessage.ToolCall.ToolCallFunction(
+                            name=tool_call[1], arguments=json.dumps(tool_call[2], ensure_ascii=False)
+                        ),
+                    )
+                    for tool_call in tool_calls
+                ]
+            else:
+                assistant_message.content = response
+
+            self._current_thoughts.append(assistant_message)
+
+            # save thought
+            self.save_agent_thought(
+                agent_thought_id=agent_thought_id,
+                tool_name=tool_call_names,
+                tool_input=tool_call_inputs,
+                thought=response,
+                tool_invoke_meta=None,
+                observation=None,
+                answer=response,
+                messages_ids=[],
+                llm_usage=current_llm_usage,
+            )
+            self.queue_manager.publish(
+                QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+            )
+
+            final_answer += response + "\n"
+
+            # Check if max iteration is reached and model still wants to call tools
+            if iteration_step == max_iteration_steps and tool_calls:
+                raise AgentMaxIterationError(app_config.agent.max_iteration)
+
+            # call tools
+            tool_responses = []
+            for tool_call_id, tool_call_name, tool_call_args in tool_calls:
+                tool_instance = tool_instances.get(tool_call_name)
+                if not tool_instance:
+                    tool_response = {
+                        "tool_call_id": tool_call_id,
+                        "tool_call_name": tool_call_name,
+                        "tool_response": f"there is not a tool named {tool_call_name}",
+                        "meta": ToolInvokeMeta.error_instance(f"there is not a tool named {tool_call_name}").to_dict(),
+                    }
+                else:
+                    # invoke tool
+                    tool_invoke_response, message_files, tool_invoke_meta = ToolEngine.agent_invoke(
+                        tool=tool_instance,
+                        tool_parameters=tool_call_args,
+                        user_id=self.user_id,
+                        tenant_id=self.tenant_id,
+                        message=self.message,
+                        invoke_from=self.application_generate_entity.invoke_from,
+                        agent_tool_callback=self.agent_callback,
+                        trace_manager=trace_manager,
+                        app_id=self.application_generate_entity.app_config.app_id,
+                        message_id=self.message.id,
+                        conversation_id=self.conversation.id,
+                    )
+                    # publish files
+                    for message_file_id in message_files:
+                        # publish message file
+                        self.queue_manager.publish(
+                            QueueMessageFileEvent(message_file_id=message_file_id), PublishFrom.APPLICATION_MANAGER
+                        )
+                        # add message file ids
+                        message_file_ids.append(message_file_id)
+
+                    tool_response = {
+                        "tool_call_id": tool_call_id,
+                        "tool_call_name": tool_call_name,
+                        "tool_response": tool_invoke_response,
+                        "meta": tool_invoke_meta.to_dict(),
+                    }
+
+                tool_responses.append(tool_response)
+                if tool_response["tool_response"] is not None:
+                    self._current_thoughts.append(
+                        ToolPromptMessage(
+                            content=str(tool_response["tool_response"]),
+                            tool_call_id=tool_call_id,
+                            name=tool_call_name,
+                        )
+                    )
+
+            if len(tool_responses) > 0:
+                # save agent thought
+                self.save_agent_thought(
+                    agent_thought_id=agent_thought_id,
+                    tool_name="",
+                    tool_input="",
+                    thought="",
+                    tool_invoke_meta={
+                        tool_response["tool_call_name"]: tool_response["meta"] for tool_response in tool_responses
+                    },
+                    observation={
+                        tool_response["tool_call_name"]: tool_response["tool_response"]
+                        for tool_response in tool_responses
+                    },
+                    answer="",
+                    messages_ids=message_file_ids,
+                )
+                self.queue_manager.publish(
+                    QueueAgentThoughtEvent(agent_thought_id=agent_thought_id), PublishFrom.APPLICATION_MANAGER
+                )
+
+            # update prompt tool
+            for prompt_tool in prompt_messages_tools:
+                self.update_prompt_message_tool(tool_instances[prompt_tool.name], prompt_tool)
+
+            iteration_step += 1
+
+        # publish end event
+        self.queue_manager.publish(
+            QueueMessageEndEvent(
+                llm_result=LLMResult(
+                    model=model_instance.model,
+                    prompt_messages=prompt_messages,
+                    message=AssistantPromptMessage(content=final_answer),
+                    usage=llm_usage["usage"] or LLMUsage.empty_usage(),
+                    system_fingerprint="",
+                )
+            ),
+            PublishFrom.APPLICATION_MANAGER,
+        )
+
+    def check_tool_calls(self, llm_result_chunk: LLMResultChunk) -> bool:
+        """
+        Check if there is any tool call in llm result chunk
+        """
+        if llm_result_chunk.delta.message.tool_calls:
+            return True
+        return False
+
+    def check_blocking_tool_calls(self, llm_result: LLMResult) -> bool:
+        """
+        Check if there is any blocking tool call in llm result
+        """
+        if llm_result.message.tool_calls:
+            return True
+        return False
+
+    def extract_tool_calls(self, llm_result_chunk: LLMResultChunk) -> list[tuple[str, str, dict[str, Any]]]:
+        """
+        Extract tool calls from llm result chunk
+
+        Returns:
+            List[Tuple[str, str, Dict[str, Any]]]: [(tool_call_id, tool_call_name, tool_call_args)]
+        """
+        tool_calls = []
+        for prompt_message in llm_result_chunk.delta.message.tool_calls:
+            args = {}
+            if prompt_message.function.arguments != "":
+                args = json.loads(prompt_message.function.arguments)
+
+            tool_calls.append(
+                (
+                    prompt_message.id,
+                    prompt_message.function.name,
+                    args,
+                )
+            )
+
+        return tool_calls
+
+    def extract_blocking_tool_calls(self, llm_result: LLMResult) -> list[tuple[str, str, dict[str, Any]]]:
+        """
+        Extract blocking tool calls from llm result
+
+        Returns:
+            List[Tuple[str, str, Dict[str, Any]]]: [(tool_call_id, tool_call_name, tool_call_args)]
+        """
+        tool_calls = []
+        for prompt_message in llm_result.message.tool_calls:
+            args = {}
+            if prompt_message.function.arguments != "":
+                args = json.loads(prompt_message.function.arguments)
+
+            tool_calls.append(
+                (
+                    prompt_message.id,
+                    prompt_message.function.name,
+                    args,
+                )
+            )
+
+        return tool_calls
+
+    def _init_system_message(self, prompt_template: str, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
+        """
+        Initialize system message
+        """
+        if not prompt_messages and prompt_template:
+            return [
+                SystemPromptMessage(content=prompt_template),
+            ]
+
+        if prompt_messages and not isinstance(prompt_messages[0], SystemPromptMessage) and prompt_template:
+            prompt_messages.insert(0, SystemPromptMessage(content=prompt_template))
+
+        return prompt_messages or []
+
+    def _organize_user_query(self, query: str, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
+        """
+        Organize user query
+        """
+        if self.files:
+            # get image detail config
+            image_detail_config = (
+                self.application_generate_entity.file_upload_config.image_config.detail
+                if (
+                    self.application_generate_entity.file_upload_config
+                    and self.application_generate_entity.file_upload_config.image_config
+                )
+                else None
+            )
+            image_detail_config = image_detail_config or ImagePromptMessageContent.DETAIL.LOW
+
+            prompt_message_contents: list[PromptMessageContentUnionTypes] = []
+            for file in self.files:
+                prompt_message_contents.append(
+                    file_manager.to_prompt_message_content(
+                        file,
+                        image_detail_config=image_detail_config,
+                    )
+                )
+            prompt_message_contents.append(TextPromptMessageContent(data=query))
+
+            prompt_messages.append(UserPromptMessage(content=prompt_message_contents))
+        else:
+            prompt_messages.append(UserPromptMessage(content=query))
+
+        return prompt_messages
+
+    def _clear_user_prompt_image_messages(self, prompt_messages: list[PromptMessage]) -> list[PromptMessage]:
+        """
+        As for now, gpt supports both fc and vision at the first iteration.
+        We need to remove the image messages from the prompt messages at the first iteration.
+        """
+        prompt_messages = deepcopy(prompt_messages)
+
+        for prompt_message in prompt_messages:
+            if isinstance(prompt_message, UserPromptMessage):
+                if isinstance(prompt_message.content, list):
+                    prompt_message.content = "\n".join(
+                        [
+                            content.data
+                            if content.type == PromptMessageContentType.TEXT
+                            else "[image]"
+                            if content.type == PromptMessageContentType.IMAGE
+                            else "[file]"
+                            for content in prompt_message.content
+                        ]
+                    )
+
+        return prompt_messages
+
+    def _organize_prompt_messages(self):
+        prompt_template = self.app_config.prompt_template.simple_prompt_template or ""
+        self.history_prompt_messages = self._init_system_message(prompt_template, self.history_prompt_messages)
+        query_prompt_messages = self._organize_user_query(self.query or "", [])
+
+        self.history_prompt_messages = AgentHistoryPromptTransform(
+            model_config=self.model_config,
+            prompt_messages=[*query_prompt_messages, *self._current_thoughts],
+            history_messages=self.history_prompt_messages,
+            memory=self.memory,
+        ).get_prompt()
+
+        prompt_messages = [*self.history_prompt_messages, *query_prompt_messages, *self._current_thoughts]
+        if len(self._current_thoughts) != 0:
+            # clear messages after the first iteration
+            prompt_messages = self._clear_user_prompt_image_messages(prompt_messages)
+        return prompt_messages

api/core/agent/patterns/README.md

@@ -1,55 +0,0 @@
-# Agent Patterns
-
-A unified agent pattern module that powers both Agent V2 workflow nodes and agent applications. Strategies share a common execution contract while adapting to model capabilities and tool availability.
-
-## Overview
-
-The module applies a strategy pattern around LLM/tool orchestration. `StrategyFactory` auto-selects the best implementation based on model features or an explicit agent strategy, and each strategy streams logs and usage consistently.
-
-## Key Features
-
-- **Dual strategies**
-  - `FunctionCallStrategy`: uses native LLM function/tool calling when the model exposes `TOOL_CALL`, `MULTI_TOOL_CALL`, or `STREAM_TOOL_CALL`.
-  - `ReActStrategy`: ReAct (reasoning + acting) flow driven by `CotAgentOutputParser`, used when function calling is unavailable or explicitly requested.
-- **Explicit or auto selection**
-  - `StrategyFactory.create_strategy` prefers an explicit `AgentEntity.Strategy` (FUNCTION_CALLING or CHAIN_OF_THOUGHT).
-  - Otherwise it falls back to function calling when tool-call features exist, or ReAct when they do not.
-- **Unified execution contract**
-  - `AgentPattern.run` yields streaming `AgentLog` entries and `LLMResultChunk` data, returning an `AgentResult` with text, files, usage, and `finish_reason`.
-  - Iterations are configurable and hard-capped at 99 rounds; the last round forces a final answer by withholding tools.
-- **Tool handling and hooks**
-  - Tools convert to `PromptMessageTool` objects before invocation.
-  - Optional `tool_invoke_hook` lets callers override tool execution (e.g., agent apps) while workflow runs use `ToolEngine.generic_invoke`.
-  - Tool outputs support text, links, JSON, variables, blobs, retriever resources, and file attachments; `target=="self"` files are reloaded into model context, others are returned as outputs.
-- **File-aware arguments**
-  - Tool args accept `[File: <id>]` or `[Files: <id1, id2>]` placeholders that resolve to `File` objects before invocation, enabling models to reference uploaded files safely.
-- **ReAct prompt shaping**
-  - System prompts replace `{{instruction}}`, `{{tools}}`, and `{{tool_names}}` placeholders.
-  - Adds `Observation` to stop sequences and appends scratchpad text so the model sees prior Thought/Action/Observation history.
-- **Observability and accounting**
-  - Standardized `AgentLog` entries for rounds, model thoughts, and tool calls, including usage aggregation (`LLMUsage`) across streaming and non-streaming paths.
-
-## Architecture
-
-```
-agent/patterns/
-├── base.py              # Shared utilities: logging, usage, tool invocation, file handling
-├── function_call.py     # Native function-calling loop with tool execution
-├── react.py             # ReAct loop with CoT parsing and scratchpad wiring
-└── strategy_factory.py  # Strategy selection by model features or explicit override
-```
-
-## Usage
-
-- For auto-selection:
-  - Call `StrategyFactory.create_strategy(model_features, model_instance, context, tools, files, ...)` and run the returned strategy with prompt messages and model params.
-- For explicit behavior:
-  - Pass `agent_strategy=AgentEntity.Strategy.FUNCTION_CALLING` to force native calls (falls back to ReAct if unsupported), or `CHAIN_OF_THOUGHT` to force ReAct.
-- Both strategies stream chunks and logs; collect the generator output until it returns an `AgentResult`.
-
-## Integration Points
-
-- **Model runtime**: delegates to `ModelInstance.invoke_llm` for both streaming and non-streaming calls.
-- **Tool system**: defaults to `ToolEngine.generic_invoke`, with `tool_invoke_hook` for custom callers.
-- **Files**: flows through `File` objects for tool inputs/outputs and model-context attachments.
-- **Execution context**: `ExecutionContext` fields (user/app/conversation/message) propagate to tool invocations and logging.

api/core/agent/patterns/__init__.py

@@ -1,19 +0,0 @@
-"""Agent patterns module.
-
-This module provides different strategies for agent execution:
-- FunctionCallStrategy: Uses native function/tool calling
-- ReActStrategy: Uses ReAct (Reasoning + Acting) approach
-- StrategyFactory: Factory for creating strategies based on model features
-"""
-
-from .base import AgentPattern
-from .function_call import FunctionCallStrategy
-from .react import ReActStrategy
-from .strategy_factory import StrategyFactory
-
-__all__ = [
-    "AgentPattern",
-    "FunctionCallStrategy",
-    "ReActStrategy",
-    "StrategyFactory",
-]

api/core/agent/patterns/base.py

@@ -1,474 +0,0 @@
-"""Base class for agent strategies."""
-
-from __future__ import annotations
-
-import json
-import re
-import time
-from abc import ABC, abstractmethod
-from collections.abc import Callable, Generator
-from typing import TYPE_CHECKING, Any
-
-from core.agent.entities import AgentLog, AgentResult, ExecutionContext
-from core.file import File
-from core.model_manager import ModelInstance
-from core.model_runtime.entities import (
-    AssistantPromptMessage,
-    LLMResult,
-    LLMResultChunk,
-    LLMResultChunkDelta,
-    PromptMessage,
-    PromptMessageTool,
-)
-from core.model_runtime.entities.llm_entities import LLMUsage
-from core.model_runtime.entities.message_entities import TextPromptMessageContent
-from core.tools.entities.tool_entities import ToolInvokeMessage, ToolInvokeMeta
-
-if TYPE_CHECKING:
-    from core.tools.__base.tool import Tool
-
-# Type alias for tool invoke hook
-# Returns: (response_content, message_file_ids, tool_invoke_meta)
-ToolInvokeHook = Callable[["Tool", dict[str, Any], str], tuple[str, list[str], ToolInvokeMeta]]
-
-
-class AgentPattern(ABC):
-    """Base class for agent execution strategies."""
-
-    def __init__(
-        self,
-        model_instance: ModelInstance,
-        tools: list[Tool],
-        context: ExecutionContext,
-        max_iterations: int = 10,
-        workflow_call_depth: int = 0,
-        files: list[File] = [],
-        tool_invoke_hook: ToolInvokeHook | None = None,
-    ):
-        """Initialize the agent strategy."""
-        self.model_instance = model_instance
-        self.tools = tools
-        self.context = context
-        self.max_iterations = min(max_iterations, 99)  # Cap at 99 iterations
-        self.workflow_call_depth = workflow_call_depth
-        self.files: list[File] = files
-        self.tool_invoke_hook = tool_invoke_hook
-
-    @abstractmethod
-    def run(
-        self,
-        prompt_messages: list[PromptMessage],
-        model_parameters: dict[str, Any],
-        stop: list[str] = [],
-        stream: bool = True,
-    ) -> Generator[LLMResultChunk | AgentLog, None, AgentResult]:
-        """Execute the agent strategy."""
-        pass
-
-    def _accumulate_usage(self, total_usage: dict[str, Any], delta_usage: LLMUsage) -> None:
-        """Accumulate LLM usage statistics."""
-        if not total_usage.get("usage"):
-            # Create a copy to avoid modifying the original
-            total_usage["usage"] = LLMUsage(
-                prompt_tokens=delta_usage.prompt_tokens,
-                prompt_unit_price=delta_usage.prompt_unit_price,
-                prompt_price_unit=delta_usage.prompt_price_unit,
-                prompt_price=delta_usage.prompt_price,
-                completion_tokens=delta_usage.completion_tokens,
-                completion_unit_price=delta_usage.completion_unit_price,
-                completion_price_unit=delta_usage.completion_price_unit,
-                completion_price=delta_usage.completion_price,
-                total_tokens=delta_usage.total_tokens,
-                total_price=delta_usage.total_price,
-                currency=delta_usage.currency,
-                latency=delta_usage.latency,
-            )
-        else:
-            current: LLMUsage = total_usage["usage"]
-            current.prompt_tokens += delta_usage.prompt_tokens
-            current.completion_tokens += delta_usage.completion_tokens
-            current.total_tokens += delta_usage.total_tokens
-            current.prompt_price += delta_usage.prompt_price
-            current.completion_price += delta_usage.completion_price
-            current.total_price += delta_usage.total_price
-
-    def _extract_content(self, content: Any) -> str:
-        """Extract text content from message content."""
-        if isinstance(content, list):
-            # Content items are PromptMessageContentUnionTypes
-            text_parts = []
-            for c in content:
-                # Check if it's a TextPromptMessageContent (which has data attribute)
-                if isinstance(c, TextPromptMessageContent):
-                    text_parts.append(c.data)
-            return "".join(text_parts)
-        return str(content)
-
-    def _has_tool_calls(self, chunk: LLMResultChunk) -> bool:
-        """Check if chunk contains tool calls."""
-        # LLMResultChunk always has delta attribute
-        return bool(chunk.delta.message and chunk.delta.message.tool_calls)
-
-    def _has_tool_calls_result(self, result: LLMResult) -> bool:
-        """Check if result contains tool calls (non-streaming)."""
-        # LLMResult always has message attribute
-        return bool(result.message and result.message.tool_calls)
-
-    def _extract_tool_calls(self, chunk: LLMResultChunk) -> list[tuple[str, str, dict[str, Any]]]:
-        """Extract tool calls from streaming chunk."""
-        tool_calls: list[tuple[str, str, dict[str, Any]]] = []
-        if chunk.delta.message and chunk.delta.message.tool_calls:
-            for tool_call in chunk.delta.message.tool_calls:
-                if tool_call.function:
-                    try:
-                        args = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
-                    except json.JSONDecodeError:
-                        args = {}
-                    tool_calls.append((tool_call.id or "", tool_call.function.name, args))
-        return tool_calls
-
-    def _extract_tool_calls_result(self, result: LLMResult) -> list[tuple[str, str, dict[str, Any]]]:
-        """Extract tool calls from non-streaming result."""
-        tool_calls = []
-        if result.message and result.message.tool_calls:
-            for tool_call in result.message.tool_calls:
-                if tool_call.function:
-                    try:
-                        args = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
-                    except json.JSONDecodeError:
-                        args = {}
-                    tool_calls.append((tool_call.id or "", tool_call.function.name, args))
-        return tool_calls
-
-    def _extract_text_from_message(self, message: PromptMessage) -> str:
-        """Extract text content from a prompt message."""
-        # PromptMessage always has content attribute
-        content = message.content
-        if isinstance(content, str):
-            return content
-        elif isinstance(content, list):
-            # Extract text from content list
-            text_parts = []
-            for item in content:
-                if isinstance(item, TextPromptMessageContent):
-                    text_parts.append(item.data)
-            return " ".join(text_parts)
-        return ""
-
-    def _get_tool_metadata(self, tool_instance: Tool) -> dict[AgentLog.LogMetadata, Any]:
-        """Get metadata for a tool including provider and icon info."""
-        from core.tools.tool_manager import ToolManager
-
-        metadata: dict[AgentLog.LogMetadata, Any] = {}
-        if tool_instance.entity and tool_instance.entity.identity:
-            identity = tool_instance.entity.identity
-            if identity.provider:
-                metadata[AgentLog.LogMetadata.PROVIDER] = identity.provider
-
-            # Get icon using ToolManager for proper URL generation
-            tenant_id = self.context.tenant_id
-            if tenant_id and identity.provider:
-                try:
-                    provider_type = tool_instance.tool_provider_type()
-                    icon = ToolManager.get_tool_icon(tenant_id, provider_type, identity.provider)
-                    if isinstance(icon, str):
-                        metadata[AgentLog.LogMetadata.ICON] = icon
-                    elif isinstance(icon, dict):
-                        # Handle icon dict with background/content or light/dark variants
-                        metadata[AgentLog.LogMetadata.ICON] = icon
-                except Exception:
-                    # Fallback to identity.icon if ToolManager fails
-                    if identity.icon:
-                        metadata[AgentLog.LogMetadata.ICON] = identity.icon
-            elif identity.icon:
-                metadata[AgentLog.LogMetadata.ICON] = identity.icon
-        return metadata
-
-    def _create_log(
-        self,
-        label: str,
-        log_type: AgentLog.LogType,
-        status: AgentLog.LogStatus,
-        data: dict[str, Any] | None = None,
-        parent_id: str | None = None,
-        extra_metadata: dict[AgentLog.LogMetadata, Any] | None = None,
-    ) -> AgentLog:
-        """Create a new AgentLog with standard metadata."""
-        metadata: dict[AgentLog.LogMetadata, Any] = {
-            AgentLog.LogMetadata.STARTED_AT: time.perf_counter(),
-        }
-        if extra_metadata:
-            metadata.update(extra_metadata)
-
-        return AgentLog(
-            label=label,
-            log_type=log_type,
-            status=status,
-            data=data or {},
-            parent_id=parent_id,
-            metadata=metadata,
-        )
-
-    def _finish_log(
-        self,
-        log: AgentLog,
-        data: dict[str, Any] | None = None,
-        usage: LLMUsage | None = None,
-    ) -> AgentLog:
-        """Finish an AgentLog by updating its status and metadata."""
-        log.status = AgentLog.LogStatus.SUCCESS
-
-        if data is not None:
-            log.data = data
-
-        # Calculate elapsed time
-        started_at = log.metadata.get(AgentLog.LogMetadata.STARTED_AT, time.perf_counter())
-        finished_at = time.perf_counter()
-
-        # Update metadata
-        log.metadata = {
-            **log.metadata,
-            AgentLog.LogMetadata.FINISHED_AT: finished_at,
-            # Calculate elapsed time in seconds
-            AgentLog.LogMetadata.ELAPSED_TIME: round(finished_at - started_at, 4),
-        }
-
-        # Add usage information if provided
-        if usage:
-            log.metadata.update(
-                {
-                    AgentLog.LogMetadata.TOTAL_PRICE: usage.total_price,
-                    AgentLog.LogMetadata.CURRENCY: usage.currency,
-                    AgentLog.LogMetadata.TOTAL_TOKENS: usage.total_tokens,
-                    AgentLog.LogMetadata.LLM_USAGE: usage,
-                }
-            )
-
-        return log
-
-    def _replace_file_references(self, tool_args: dict[str, Any]) -> dict[str, Any]:
-        """
-        Replace file references in tool arguments with actual File objects.
-
-        Args:
-            tool_args: Dictionary of tool arguments
-
-        Returns:
-            Updated tool arguments with file references replaced
-        """
-        # Process each argument in the dictionary
-        processed_args: dict[str, Any] = {}
-        for key, value in tool_args.items():
-            processed_args[key] = self._process_file_reference(value)
-        return processed_args
-
-    def _process_file_reference(self, data: Any) -> Any:
-        """
-        Recursively process data to replace file references.
-        Supports both single file [File: file_id] and multiple files [Files: file_id1, file_id2, ...].
-
-        Args:
-            data: The data to process (can be dict, list, str, or other types)
-
-        Returns:
-            Processed data with file references replaced
-        """
-        single_file_pattern = re.compile(r"^\[File:\s*([^\]]+)\]$")
-        multiple_files_pattern = re.compile(r"^\[Files:\s*([^\]]+)\]$")
-
-        if isinstance(data, dict):
-            # Process dictionary recursively
-            return {key: self._process_file_reference(value) for key, value in data.items()}
-        elif isinstance(data, list):
-            # Process list recursively
-            return [self._process_file_reference(item) for item in data]
-        elif isinstance(data, str):
-            # Check for single file pattern [File: file_id]
-            single_match = single_file_pattern.match(data.strip())
-            if single_match:
-                file_id = single_match.group(1).strip()
-                # Find the file in self.files
-                for file in self.files:
-                    if file.id and str(file.id) == file_id:
-                        return file
-                # If file not found, return original value
-                return data
-
-            # Check for multiple files pattern [Files: file_id1, file_id2, ...]
-            multiple_match = multiple_files_pattern.match(data.strip())
-            if multiple_match:
-                file_ids_str = multiple_match.group(1).strip()
-                # Split by comma and strip whitespace
-                file_ids = [fid.strip() for fid in file_ids_str.split(",")]
-
-                # Find all matching files
-                matched_files: list[File] = []
-                for file_id in file_ids:
-                    for file in self.files:
-                        if file.id and str(file.id) == file_id:
-                            matched_files.append(file)
-                            break
-
-                # Return list of files if any were found, otherwise return original
-                return matched_files or data
-
-            return data
-        else:
-            # Return other types as-is
-            return data
-
-    def _create_text_chunk(self, text: str, prompt_messages: list[PromptMessage]) -> LLMResultChunk:
-        """Create a text chunk for streaming."""
-        return LLMResultChunk(
-            model=self.model_instance.model,
-            prompt_messages=prompt_messages,
-            delta=LLMResultChunkDelta(
-                index=0,
-                message=AssistantPromptMessage(content=text),
-                usage=None,
-            ),
-            system_fingerprint="",
-        )
-
-    def _invoke_tool(
-        self,
-        tool_instance: Tool,
-        tool_args: dict[str, Any],
-        tool_name: str,
-    ) -> tuple[str, list[File], ToolInvokeMeta | None]:
-        """
-        Invoke a tool and collect its response.
-
-        Args:
-            tool_instance: The tool instance to invoke
-            tool_args: Tool arguments
-            tool_name: Name of the tool
-
-        Returns:
-            Tuple of (response_content, tool_files, tool_invoke_meta)
-        """
-        # Process tool_args to replace file references with actual File objects
-        tool_args = self._replace_file_references(tool_args)
-
-        # If a tool invoke hook is set, use it instead of generic_invoke
-        if self.tool_invoke_hook:
-            response_content, _, tool_invoke_meta = self.tool_invoke_hook(tool_instance, tool_args, tool_name)
-            # Note: message_file_ids are stored in DB, we don't convert them to File objects here
-            # The caller (AgentAppRunner) handles file publishing
-            return response_content, [], tool_invoke_meta
-
-        # Default: use generic_invoke for workflow scenarios
-        # Import here to avoid circular import
-        from core.tools.tool_engine import DifyWorkflowCallbackHandler, ToolEngine
-
-        tool_response = ToolEngine().generic_invoke(
-            tool=tool_instance,
-            tool_parameters=tool_args,
-            user_id=self.context.user_id or "",
-            workflow_tool_callback=DifyWorkflowCallbackHandler(),
-            workflow_call_depth=self.workflow_call_depth,
-            app_id=self.context.app_id,
-            conversation_id=self.context.conversation_id,
-            message_id=self.context.message_id,
-        )
-
-        # Collect response and files
-        response_content = ""
-        tool_files: list[File] = []
-
-        for response in tool_response:
-            if response.type == ToolInvokeMessage.MessageType.TEXT:
-                assert isinstance(response.message, ToolInvokeMessage.TextMessage)
-                response_content += response.message.text
-
-            elif response.type == ToolInvokeMessage.MessageType.LINK:
-                # Handle link messages
-                if isinstance(response.message, ToolInvokeMessage.TextMessage):
-                    response_content += f"[Link: {response.message.text}]"
-
-            elif response.type == ToolInvokeMessage.MessageType.IMAGE:
-                # Handle image URL messages
-                if isinstance(response.message, ToolInvokeMessage.TextMessage):
-                    response_content += f"[Image: {response.message.text}]"
-
-            elif response.type == ToolInvokeMessage.MessageType.IMAGE_LINK:
-                # Handle image link messages
-                if isinstance(response.message, ToolInvokeMessage.TextMessage):
-                    response_content += f"[Image: {response.message.text}]"
-
-            elif response.type == ToolInvokeMessage.MessageType.BINARY_LINK:
-                # Handle binary file link messages
-                if isinstance(response.message, ToolInvokeMessage.TextMessage):
-                    filename = response.meta.get("filename", "file") if response.meta else "file"
-                    response_content += f"[File: {filename} - {response.message.text}]"
-
-            elif response.type == ToolInvokeMessage.MessageType.JSON:
-                # Handle JSON messages
-                if isinstance(response.message, ToolInvokeMessage.JsonMessage):
-                    response_content += json.dumps(response.message.json_object, ensure_ascii=False, indent=2)
-
-            elif response.type == ToolInvokeMessage.MessageType.BLOB:
-                # Handle blob messages - convert to text representation
-                if isinstance(response.message, ToolInvokeMessage.BlobMessage):
-                    mime_type = (
-                        response.meta.get("mime_type", "application/octet-stream")
-                        if response.meta
-                        else "application/octet-stream"
-                    )
-                    size = len(response.message.blob)
-                    response_content += f"[Binary data: {mime_type}, size: {size} bytes]"
-
-            elif response.type == ToolInvokeMessage.MessageType.VARIABLE:
-                # Handle variable messages
-                if isinstance(response.message, ToolInvokeMessage.VariableMessage):
-                    var_name = response.message.variable_name
-                    var_value = response.message.variable_value
-                    if isinstance(var_value, str):
-                        response_content += var_value
-                    else:
-                        response_content += f"[Variable {var_name}: {json.dumps(var_value, ensure_ascii=False)}]"
-
-            elif response.type == ToolInvokeMessage.MessageType.BLOB_CHUNK:
-                # Handle blob chunk messages - these are parts of a larger blob
-                if isinstance(response.message, ToolInvokeMessage.BlobChunkMessage):
-                    response_content += f"[Blob chunk {response.message.sequence}: {len(response.message.blob)} bytes]"
-
-            elif response.type == ToolInvokeMessage.MessageType.RETRIEVER_RESOURCES:
-                # Handle retriever resources messages
-                if isinstance(response.message, ToolInvokeMessage.RetrieverResourceMessage):
-                    response_content += response.message.context
-
-            elif response.type == ToolInvokeMessage.MessageType.FILE:
-                # Extract file from meta
-                if response.meta and "file" in response.meta:
-                    file = response.meta["file"]
-                    if isinstance(file, File):
-                        # Check if file is for model or tool output
-                        if response.meta.get("target") == "self":
-                            # File is for model - add to files for next prompt
-                            self.files.append(file)
-                            response_content += f"File '{file.filename}' has been loaded into your context."
-                        else:
-                            # File is tool output
-                            tool_files.append(file)
-
-        return response_content, tool_files, None
-
-    def _find_tool_by_name(self, tool_name: str) -> Tool | None:
-        """Find a tool instance by its name."""
-        for tool in self.tools:
-            if tool.entity.identity.name == tool_name:
-                return tool
-        return None
-
-    def _convert_tools_to_prompt_format(self) -> list[PromptMessageTool]:
-        """Convert tools to prompt message format."""
-        prompt_tools: list[PromptMessageTool] = []
-        for tool in self.tools:
-            prompt_tools.append(tool.to_prompt_message_tool())
-        return prompt_tools
-
-    def _update_usage_with_empty(self, llm_usage: dict[str, Any]) -> None:
-        """Initialize usage tracking with empty usage if not set."""
-        if "usage" not in llm_usage or llm_usage["usage"] is None:
-            llm_usage["usage"] = LLMUsage.empty_usage()

api/core/agent/patterns/function_call.py

@@ -1,299 +0,0 @@
-"""Function Call strategy implementation."""
-
-import json
-from collections.abc import Generator
-from typing import Any, Union
-
-from core.agent.entities import AgentLog, AgentResult
-from core.file import File
-from core.model_runtime.entities import (
-    AssistantPromptMessage,
-    LLMResult,
-    LLMResultChunk,
-    LLMResultChunkDelta,
-    LLMUsage,
-    PromptMessage,
-    PromptMessageTool,
-    ToolPromptMessage,
-)
-from core.tools.entities.tool_entities import ToolInvokeMeta
-
-from .base import AgentPattern
-
-
-class FunctionCallStrategy(AgentPattern):
-    """Function Call strategy using model's native tool calling capability."""
-
-    def run(
-        self,
-        prompt_messages: list[PromptMessage],
-        model_parameters: dict[str, Any],
-        stop: list[str] = [],
-        stream: bool = True,
-    ) -> Generator[LLMResultChunk | AgentLog, None, AgentResult]:
-        """Execute the function call agent strategy."""
-        # Convert tools to prompt format
-        prompt_tools: list[PromptMessageTool] = self._convert_tools_to_prompt_format()
-
-        # Initialize tracking
-        iteration_step: int = 1
-        max_iterations: int = self.max_iterations + 1
-        function_call_state: bool = True
-        total_usage: dict[str, LLMUsage | None] = {"usage": None}
-        messages: list[PromptMessage] = list(prompt_messages)  # Create mutable copy
-        final_text: str = ""
-        finish_reason: str | None = None
-        output_files: list[File] = []  # Track files produced by tools
-
-        while function_call_state and iteration_step <= max_iterations:
-            function_call_state = False
-            round_log = self._create_log(
-                label=f"ROUND {iteration_step}",
-                log_type=AgentLog.LogType.ROUND,
-                status=AgentLog.LogStatus.START,
-                data={},
-            )
-            yield round_log
-            # On last iteration, remove tools to force final answer
-            current_tools: list[PromptMessageTool] = [] if iteration_step == max_iterations else prompt_tools
-            model_log = self._create_log(
-                label=f"{self.model_instance.model} Thought",
-                log_type=AgentLog.LogType.THOUGHT,
-                status=AgentLog.LogStatus.START,
-                data={},
-                parent_id=round_log.id,
-                extra_metadata={
-                    AgentLog.LogMetadata.PROVIDER: self.model_instance.provider,
-                },
-            )
-            yield model_log
-
-            # Track usage for this round only
-            round_usage: dict[str, LLMUsage | None] = {"usage": None}
-
-            # Invoke model
-            chunks: Union[Generator[LLMResultChunk, None, None], LLMResult] = self.model_instance.invoke_llm(
-                prompt_messages=messages,
-                model_parameters=model_parameters,
-                tools=current_tools,
-                stop=stop,
-                stream=stream,
-                user=self.context.user_id,
-                callbacks=[],
-            )
-
-            # Process response
-            tool_calls, response_content, chunk_finish_reason = yield from self._handle_chunks(
-                chunks, round_usage, model_log
-            )
-            messages.append(self._create_assistant_message(response_content, tool_calls))
-
-            # Accumulate to total usage
-            round_usage_value = round_usage.get("usage")
-            if round_usage_value:
-                self._accumulate_usage(total_usage, round_usage_value)
-
-            # Update final text if no tool calls (this is likely the final answer)
-            if not tool_calls:
-                final_text = response_content
-
-            # Update finish reason
-            if chunk_finish_reason:
-                finish_reason = chunk_finish_reason
-
-            # Process tool calls
-            tool_outputs: dict[str, str] = {}
-            if tool_calls:
-                function_call_state = True
-                # Execute tools
-                for tool_call_id, tool_name, tool_args in tool_calls:
-                    tool_response, tool_files, _ = yield from self._handle_tool_call(
-                        tool_name, tool_args, tool_call_id, messages, round_log
-                    )
-                    tool_outputs[tool_name] = tool_response
-                    # Track files produced by tools
-                    output_files.extend(tool_files)
-            yield self._finish_log(
-                round_log,
-                data={
-                    "llm_result": response_content,
-                    "tool_calls": [
-                        {"name": tc[1], "args": tc[2], "output": tool_outputs.get(tc[1], "")} for tc in tool_calls
-                    ]
-                    if tool_calls
-                    else [],
-                    "final_answer": final_text if not function_call_state else None,
-                },
-                usage=round_usage.get("usage"),
-            )
-            iteration_step += 1
-
-        # Return final result
-        from core.agent.entities import AgentResult
-
-        return AgentResult(
-            text=final_text,
-            files=output_files,
-            usage=total_usage.get("usage") or LLMUsage.empty_usage(),
-            finish_reason=finish_reason,
-        )
-
-    def _handle_chunks(
-        self,
-        chunks: Union[Generator[LLMResultChunk, None, None], LLMResult],
-        llm_usage: dict[str, LLMUsage | None],
-        start_log: AgentLog,
-    ) -> Generator[
-        LLMResultChunk | AgentLog,
-        None,
-        tuple[list[tuple[str, str, dict[str, Any]]], str, str | None],
-    ]:
-        """Handle LLM response chunks and extract tool calls and content.
-
-        Returns a tuple of (tool_calls, response_content, finish_reason).
-        """
-        tool_calls: list[tuple[str, str, dict[str, Any]]] = []
-        response_content: str = ""
-        finish_reason: str | None = None
-        if isinstance(chunks, Generator):
-            # Streaming response
-            for chunk in chunks:
-                # Extract tool calls
-                if self._has_tool_calls(chunk):
-                    tool_calls.extend(self._extract_tool_calls(chunk))
-
-                # Extract content
-                if chunk.delta.message and chunk.delta.message.content:
-                    response_content += self._extract_content(chunk.delta.message.content)
-
-                # Track usage
-                if chunk.delta.usage:
-                    self._accumulate_usage(llm_usage, chunk.delta.usage)
-
-                # Capture finish reason
-                if chunk.delta.finish_reason:
-                    finish_reason = chunk.delta.finish_reason
-
-                yield chunk
-        else:
-            # Non-streaming response
-            result: LLMResult = chunks
-
-            if self._has_tool_calls_result(result):
-                tool_calls.extend(self._extract_tool_calls_result(result))
-
-            if result.message and result.message.content:
-                response_content += self._extract_content(result.message.content)
-
-            if result.usage:
-                self._accumulate_usage(llm_usage, result.usage)
-
-            # Convert to streaming format
-            yield LLMResultChunk(
-                model=result.model,
-                prompt_messages=result.prompt_messages,
-                delta=LLMResultChunkDelta(index=0, message=result.message, usage=result.usage),
-            )
-        yield self._finish_log(
-            start_log,
-            data={
-                "result": response_content,
-            },
-            usage=llm_usage.get("usage"),
-        )
-        return tool_calls, response_content, finish_reason
-
-    def _create_assistant_message(
-        self, content: str, tool_calls: list[tuple[str, str, dict[str, Any]]] | None = None
-    ) -> AssistantPromptMessage:
-        """Create assistant message with tool calls."""
-        if tool_calls is None:
-            return AssistantPromptMessage(content=content)
-        return AssistantPromptMessage(
-            content=content or "",
-            tool_calls=[
-                AssistantPromptMessage.ToolCall(
-                    id=tc[0],
-                    type="function",
-                    function=AssistantPromptMessage.ToolCall.ToolCallFunction(name=tc[1], arguments=json.dumps(tc[2])),
-                )
-                for tc in tool_calls
-            ],
-        )
-
-    def _handle_tool_call(
-        self,
-        tool_name: str,
-        tool_args: dict[str, Any],
-        tool_call_id: str,
-        messages: list[PromptMessage],
-        round_log: AgentLog,
-    ) -> Generator[AgentLog, None, tuple[str, list[File], ToolInvokeMeta | None]]:
-        """Handle a single tool call and return response with files and meta."""
-        # Find tool
-        tool_instance = self._find_tool_by_name(tool_name)
-        if not tool_instance:
-            raise ValueError(f"Tool {tool_name} not found")
-
-        # Get tool metadata (provider, icon, etc.)
-        tool_metadata = self._get_tool_metadata(tool_instance)
-
-        # Create tool call log
-        tool_call_log = self._create_log(
-            label=f"CALL {tool_name}",
-            log_type=AgentLog.LogType.TOOL_CALL,
-            status=AgentLog.LogStatus.START,
-            data={
-                "tool_call_id": tool_call_id,
-                "tool_name": tool_name,
-                "tool_args": tool_args,
-            },
-            parent_id=round_log.id,
-            extra_metadata=tool_metadata,
-        )
-        yield tool_call_log
-
-        # Invoke tool using base class method with error handling
-        try:
-            response_content, tool_files, tool_invoke_meta = self._invoke_tool(tool_instance, tool_args, tool_name)
-
-            yield self._finish_log(
-                tool_call_log,
-                data={
-                    **tool_call_log.data,
-                    "output": response_content,
-                    "files": len(tool_files),
-                    "meta": tool_invoke_meta.to_dict() if tool_invoke_meta else None,
-                },
-            )
-            final_content = response_content or "Tool executed successfully"
-            # Add tool response to messages
-            messages.append(
-                ToolPromptMessage(
-                    content=final_content,
-                    tool_call_id=tool_call_id,
-                    name=tool_name,
-                )
-            )
-            return response_content, tool_files, tool_invoke_meta
-        except Exception as e:
-            # Tool invocation failed, yield error log
-            error_message = str(e)
-            tool_call_log.status = AgentLog.LogStatus.ERROR
-            tool_call_log.error = error_message
-            tool_call_log.data = {
-                **tool_call_log.data,
-                "error": error_message,
-            }
-            yield tool_call_log
-
-            # Add error message to conversation
-            error_content = f"Tool execution failed: {error_message}"
-            messages.append(
-                ToolPromptMessage(
-                    content=error_content,
-                    tool_call_id=tool_call_id,
-                    name=tool_name,
-                )
-            )
-            return error_content, [], None

api/core/agent/patterns/react.py

@@ -1,418 +0,0 @@
-"""ReAct strategy implementation."""
-
-from __future__ import annotations
-
-import json
-from collections.abc import Generator
-from typing import TYPE_CHECKING, Any, Union
-
-from core.agent.entities import AgentLog, AgentResult, AgentScratchpadUnit, ExecutionContext
-from core.agent.output_parser.cot_output_parser import CotAgentOutputParser
-from core.file import File
-from core.model_manager import ModelInstance
-from core.model_runtime.entities import (
-    AssistantPromptMessage,
-    LLMResult,
-    LLMResultChunk,
-    LLMResultChunkDelta,
-    PromptMessage,
-    SystemPromptMessage,
-)
-
-from .base import AgentPattern, ToolInvokeHook
-
-if TYPE_CHECKING:
-    from core.tools.__base.tool import Tool
-
-
-class ReActStrategy(AgentPattern):
-    """ReAct strategy using reasoning and acting approach."""
-
-    def __init__(
-        self,
-        model_instance: ModelInstance,
-        tools: list[Tool],
-        context: ExecutionContext,
-        max_iterations: int = 10,
-        workflow_call_depth: int = 0,
-        files: list[File] = [],
-        tool_invoke_hook: ToolInvokeHook | None = None,
-        instruction: str = "",
-    ):
-        """Initialize the ReAct strategy with instruction support."""
-        super().__init__(
-            model_instance=model_instance,
-            tools=tools,
-            context=context,
-            max_iterations=max_iterations,
-            workflow_call_depth=workflow_call_depth,
-            files=files,
-            tool_invoke_hook=tool_invoke_hook,
-        )
-        self.instruction = instruction
-
-    def run(
-        self,
-        prompt_messages: list[PromptMessage],
-        model_parameters: dict[str, Any],
-        stop: list[str] = [],
-        stream: bool = True,
-    ) -> Generator[LLMResultChunk | AgentLog, None, AgentResult]:
-        """Execute the ReAct agent strategy."""
-        # Initialize tracking
-        agent_scratchpad: list[AgentScratchpadUnit] = []
-        iteration_step: int = 1
-        max_iterations: int = self.max_iterations + 1
-        react_state: bool = True
-        total_usage: dict[str, Any] = {"usage": None}
-        output_files: list[File] = []  # Track files produced by tools
-        final_text: str = ""
-        finish_reason: str | None = None
-
-        # Add "Observation" to stop sequences
-        if "Observation" not in stop:
-            stop = stop.copy()
-            stop.append("Observation")
-
-        while react_state and iteration_step <= max_iterations:
-            react_state = False
-            round_log = self._create_log(
-                label=f"ROUND {iteration_step}",
-                log_type=AgentLog.LogType.ROUND,
-                status=AgentLog.LogStatus.START,
-                data={},
-            )
-            yield round_log
-
-            # Build prompt with/without tools based on iteration
-            include_tools = iteration_step < max_iterations
-            current_messages = self._build_prompt_with_react_format(
-                prompt_messages, agent_scratchpad, include_tools, self.instruction
-            )
-
-            model_log = self._create_log(
-                label=f"{self.model_instance.model} Thought",
-                log_type=AgentLog.LogType.THOUGHT,
-                status=AgentLog.LogStatus.START,
-                data={},
-                parent_id=round_log.id,
-                extra_metadata={
-                    AgentLog.LogMetadata.PROVIDER: self.model_instance.provider,
-                },
-            )
-            yield model_log
-
-            # Track usage for this round only
-            round_usage: dict[str, Any] = {"usage": None}
-
-            # Use current messages directly (files are handled by base class if needed)
-            messages_to_use = current_messages
-
-            # Invoke model
-            chunks: Union[Generator[LLMResultChunk, None, None], LLMResult] = self.model_instance.invoke_llm(
-                prompt_messages=messages_to_use,
-                model_parameters=model_parameters,
-                stop=stop,
-                stream=stream,
-                user=self.context.user_id or "",
-                callbacks=[],
-            )
-
-            # Process response
-            scratchpad, chunk_finish_reason = yield from self._handle_chunks(
-                chunks, round_usage, model_log, current_messages
-            )
-            agent_scratchpad.append(scratchpad)
-
-            # Accumulate to total usage
-            round_usage_value = round_usage.get("usage")
-            if round_usage_value:
-                self._accumulate_usage(total_usage, round_usage_value)
-
-            # Update finish reason
-            if chunk_finish_reason:
-                finish_reason = chunk_finish_reason
-
-            # Check if we have an action to execute
-            if scratchpad.action and scratchpad.action.action_name.lower() != "final answer":
-                react_state = True
-                # Execute tool
-                observation, tool_files = yield from self._handle_tool_call(
-                    scratchpad.action, current_messages, round_log
-                )
-                scratchpad.observation = observation
-                # Track files produced by tools
-                output_files.extend(tool_files)
-
-                # Add observation to scratchpad for display
-                yield self._create_text_chunk(f"\nObservation: {observation}\n", current_messages)
-            else:
-                # Extract final answer
-                if scratchpad.action and scratchpad.action.action_input:
-                    final_answer = scratchpad.action.action_input
-                    if isinstance(final_answer, dict):
-                        final_answer = json.dumps(final_answer, ensure_ascii=False)
-                    final_text = str(final_answer)
-                elif scratchpad.thought:
-                    # If no action but we have thought, use thought as final answer
-                    final_text = scratchpad.thought
-
-            yield self._finish_log(
-                round_log,
-                data={
-                    "thought": scratchpad.thought,
-                    "action": scratchpad.action_str if scratchpad.action else None,
-                    "observation": scratchpad.observation or None,
-                    "final_answer": final_text if not react_state else None,
-                },
-                usage=round_usage.get("usage"),
-            )
-            iteration_step += 1
-
-        # Return final result
-
-        from core.agent.entities import AgentResult
-
-        return AgentResult(
-            text=final_text, files=output_files, usage=total_usage.get("usage"), finish_reason=finish_reason
-        )
-
-    def _build_prompt_with_react_format(
-        self,
-        original_messages: list[PromptMessage],
-        agent_scratchpad: list[AgentScratchpadUnit],
-        include_tools: bool = True,
-        instruction: str = "",
-    ) -> list[PromptMessage]:
-        """Build prompt messages with ReAct format."""
-        # Copy messages to avoid modifying original
-        messages = list(original_messages)
-
-        # Find and update the system prompt that should already exist
-        system_prompt_found = False
-        for i, msg in enumerate(messages):
-            if isinstance(msg, SystemPromptMessage):
-                system_prompt_found = True
-                # The system prompt from frontend already has the template, just replace placeholders
-
-                # Format tools
-                tools_str = ""
-                tool_names = []
-                if include_tools and self.tools:
-                    # Convert tools to prompt message tools format
-                    prompt_tools = [tool.to_prompt_message_tool() for tool in self.tools]
-                    tool_names = [tool.name for tool in prompt_tools]
-
-                    # Format tools as JSON for comprehensive information
-                    from core.model_runtime.utils.encoders import jsonable_encoder
-
-                    tools_str = json.dumps(jsonable_encoder(prompt_tools), indent=2)
-                    tool_names_str = ", ".join(f'"{name}"' for name in tool_names)
-                else:
-                    tools_str = "No tools available"
-                    tool_names_str = ""
-
-                # Replace placeholders in the existing system prompt
-                updated_content = msg.content
-                assert isinstance(updated_content, str)
-                updated_content = updated_content.replace("{{instruction}}", instruction)
-                updated_content = updated_content.replace("{{tools}}", tools_str)
-                updated_content = updated_content.replace("{{tool_names}}", tool_names_str)
-
-                # Create new SystemPromptMessage with updated content
-                messages[i] = SystemPromptMessage(content=updated_content)
-                break
-
-        # If no system prompt found, that's unexpected but add scratchpad anyway
-        if not system_prompt_found:
-            # This shouldn't happen if frontend is working correctly
-            pass
-
-        # Format agent scratchpad
-        scratchpad_str = ""
-        if agent_scratchpad:
-            scratchpad_parts: list[str] = []
-            for unit in agent_scratchpad:
-                if unit.thought:
-                    scratchpad_parts.append(f"Thought: {unit.thought}")
-                if unit.action_str:
-                    scratchpad_parts.append(f"Action:\n```\n{unit.action_str}\n```")
-                if unit.observation:
-                    scratchpad_parts.append(f"Observation: {unit.observation}")
-            scratchpad_str = "\n".join(scratchpad_parts)
-
-        # If there's a scratchpad, append it to the last message
-        if scratchpad_str:
-            messages.append(AssistantPromptMessage(content=scratchpad_str))
-
-        return messages
-
-    def _handle_chunks(
-        self,
-        chunks: Union[Generator[LLMResultChunk, None, None], LLMResult],
-        llm_usage: dict[str, Any],
-        model_log: AgentLog,
-        current_messages: list[PromptMessage],
-    ) -> Generator[
-        LLMResultChunk | AgentLog,
-        None,
-        tuple[AgentScratchpadUnit, str | None],
-    ]:
-        """Handle LLM response chunks and extract action/thought.
-
-        Returns a tuple of (scratchpad_unit, finish_reason).
-        """
-        usage_dict: dict[str, Any] = {}
-
-        # Convert non-streaming to streaming format if needed
-        if isinstance(chunks, LLMResult):
-            # Create a generator from the LLMResult
-            def result_to_chunks() -> Generator[LLMResultChunk, None, None]:
-                yield LLMResultChunk(
-                    model=chunks.model,
-                    prompt_messages=chunks.prompt_messages,
-                    delta=LLMResultChunkDelta(
-                        index=0,
-                        message=chunks.message,
-                        usage=chunks.usage,
-                        finish_reason=None,  # LLMResult doesn't have finish_reason, only streaming chunks do
-                    ),
-                    system_fingerprint=chunks.system_fingerprint or "",
-                )
-
-            streaming_chunks = result_to_chunks()
-        else:
-            streaming_chunks = chunks
-
-        react_chunks = CotAgentOutputParser.handle_react_stream_output(streaming_chunks, usage_dict)
-
-        # Initialize scratchpad unit
-        scratchpad = AgentScratchpadUnit(
-            agent_response="",
-            thought="",
-            action_str="",
-            observation="",
-            action=None,
-        )
-
-        finish_reason: str | None = None
-
-        # Process chunks
-        for chunk in react_chunks:
-            if isinstance(chunk, AgentScratchpadUnit.Action):
-                # Action detected
-                action_str = json.dumps(chunk.model_dump())
-                scratchpad.agent_response = (scratchpad.agent_response or "") + action_str
-                scratchpad.action_str = action_str
-                scratchpad.action = chunk
-
-                yield self._create_text_chunk(json.dumps(chunk.model_dump()), current_messages)
-            else:
-                # Text chunk
-                chunk_text = str(chunk)
-                scratchpad.agent_response = (scratchpad.agent_response or "") + chunk_text
-                scratchpad.thought = (scratchpad.thought or "") + chunk_text
-
-                yield self._create_text_chunk(chunk_text, current_messages)
-
-        # Update usage
-        if usage_dict.get("usage"):
-            if llm_usage.get("usage"):
-                self._accumulate_usage(llm_usage, usage_dict["usage"])
-            else:
-                llm_usage["usage"] = usage_dict["usage"]
-
-        # Clean up thought
-        scratchpad.thought = (scratchpad.thought or "").strip() or "I am thinking about how to help you"
-
-        # Finish model log
-        yield self._finish_log(
-            model_log,
-            data={
-                "thought": scratchpad.thought,
-                "action": scratchpad.action_str if scratchpad.action else None,
-            },
-            usage=llm_usage.get("usage"),
-        )
-
-        return scratchpad, finish_reason
-
-    def _handle_tool_call(
-        self,
-        action: AgentScratchpadUnit.Action,
-        prompt_messages: list[PromptMessage],
-        round_log: AgentLog,
-    ) -> Generator[AgentLog, None, tuple[str, list[File]]]:
-        """Handle tool call and return observation with files."""
-        tool_name = action.action_name
-        tool_args: dict[str, Any] | str = action.action_input
-
-        # Find tool instance first to get metadata
-        tool_instance = self._find_tool_by_name(tool_name)
-        tool_metadata = self._get_tool_metadata(tool_instance) if tool_instance else {}
-
-        # Start tool log with tool metadata
-        tool_log = self._create_log(
-            label=f"CALL {tool_name}",
-            log_type=AgentLog.LogType.TOOL_CALL,
-            status=AgentLog.LogStatus.START,
-            data={
-                "tool_name": tool_name,
-                "tool_args": tool_args,
-            },
-            parent_id=round_log.id,
-            extra_metadata=tool_metadata,
-        )
-        yield tool_log
-
-        if not tool_instance:
-            # Finish tool log with error
-            yield self._finish_log(
-                tool_log,
-                data={
-                    **tool_log.data,
-                    "error": f"Tool {tool_name} not found",
-                },
-            )
-            return f"Tool {tool_name} not found", []
-
-        # Ensure tool_args is a dict
-        tool_args_dict: dict[str, Any]
-        if isinstance(tool_args, str):
-            try:
-                tool_args_dict = json.loads(tool_args)
-            except json.JSONDecodeError:
-                tool_args_dict = {"input": tool_args}
-        elif not isinstance(tool_args, dict):
-            tool_args_dict = {"input": str(tool_args)}
-        else:
-            tool_args_dict = tool_args
-
-        # Invoke tool using base class method with error handling
-        try:
-            response_content, tool_files, tool_invoke_meta = self._invoke_tool(tool_instance, tool_args_dict, tool_name)
-
-            # Finish tool log
-            yield self._finish_log(
-                tool_log,
-                data={
-                    **tool_log.data,
-                    "output": response_content,
-                    "files": len(tool_files),
-                    "meta": tool_invoke_meta.to_dict() if tool_invoke_meta else None,
-                },
-            )
-
-            return response_content or "Tool executed successfully", tool_files
-        except Exception as e:
-            # Tool invocation failed, yield error log
-            error_message = str(e)
-            tool_log.status = AgentLog.LogStatus.ERROR
-            tool_log.error = error_message
-            tool_log.data = {
-                **tool_log.data,
-                "error": error_message,
-            }
-            yield tool_log
-
-            return f"Tool execution failed: {error_message}", []

api/core/agent/patterns/strategy_factory.py

@@ -1,107 +0,0 @@
-"""Strategy factory for creating agent strategies."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from core.agent.entities import AgentEntity, ExecutionContext
-from core.file.models import File
-from core.model_manager import ModelInstance
-from core.model_runtime.entities.model_entities import ModelFeature
-
-from .base import AgentPattern, ToolInvokeHook
-from .function_call import FunctionCallStrategy
-from .react import ReActStrategy
-
-if TYPE_CHECKING:
-    from core.tools.__base.tool import Tool
-
-
-class StrategyFactory:
-    """Factory for creating agent strategies based on model features."""
-
-    # Tool calling related features
-    TOOL_CALL_FEATURES = {ModelFeature.TOOL_CALL, ModelFeature.MULTI_TOOL_CALL, ModelFeature.STREAM_TOOL_CALL}
-
-    @staticmethod
-    def create_strategy(
-        model_features: list[ModelFeature],
-        model_instance: ModelInstance,
-        context: ExecutionContext,
-        tools: list[Tool],
-        files: list[File],
-        max_iterations: int = 10,
-        workflow_call_depth: int = 0,
-        agent_strategy: AgentEntity.Strategy | None = None,
-        tool_invoke_hook: ToolInvokeHook | None = None,
-        instruction: str = "",
-    ) -> AgentPattern:
-        """
-        Create an appropriate strategy based on model features.
-
-        Args:
-            model_features: List of model features/capabilities
-            model_instance: Model instance to use
-            context: Execution context containing trace/audit information
-            tools: Available tools
-            files: Available files
-            max_iterations: Maximum iterations for the strategy
-            workflow_call_depth: Depth of workflow calls
-            agent_strategy: Optional explicit strategy override
-            tool_invoke_hook: Optional hook for custom tool invocation (e.g., agent_invoke)
-            instruction: Optional instruction for ReAct strategy
-
-        Returns:
-            AgentStrategy instance
-        """
-        # If explicit strategy is provided and it's Function Calling, try to use it if supported
-        if agent_strategy == AgentEntity.Strategy.FUNCTION_CALLING:
-            if set(model_features) & StrategyFactory.TOOL_CALL_FEATURES:
-                return FunctionCallStrategy(
-                    model_instance=model_instance,
-                    context=context,
-                    tools=tools,
-                    files=files,
-                    max_iterations=max_iterations,
-                    workflow_call_depth=workflow_call_depth,
-                    tool_invoke_hook=tool_invoke_hook,
-                )
-            # Fallback to ReAct if FC is requested but not supported
-
-        # If explicit strategy is Chain of Thought (ReAct)
-        if agent_strategy == AgentEntity.Strategy.CHAIN_OF_THOUGHT:
-            return ReActStrategy(
-                model_instance=model_instance,
-                context=context,
-                tools=tools,
-                files=files,
-                max_iterations=max_iterations,
-                workflow_call_depth=workflow_call_depth,
-                tool_invoke_hook=tool_invoke_hook,
-                instruction=instruction,
-            )
-
-        # Default auto-selection logic
-        if set(model_features) & StrategyFactory.TOOL_CALL_FEATURES:
-            # Model supports native function calling
-            return FunctionCallStrategy(
-                model_instance=model_instance,
-                context=context,
-                tools=tools,
-                files=files,
-                max_iterations=max_iterations,
-                workflow_call_depth=workflow_call_depth,
-                tool_invoke_hook=tool_invoke_hook,
-            )
-        else:
-            # Use ReAct strategy for models without function calling
-            return ReActStrategy(
-                model_instance=model_instance,
-                context=context,
-                tools=tools,
-                files=files,
-                max_iterations=max_iterations,
-                workflow_call_depth=workflow_call_depth,
-                tool_invoke_hook=tool_invoke_hook,
-                instruction=instruction,
-            )

api/core/app/apps/advanced_chat/app_runner.py

@@ -39,7 +39,6 @@ from extensions.ext_database import db
 from extensions.ext_redis import redis_client
 from extensions.otel import WorkflowAppRunnerHandler, trace_span
 from models import Workflow
-from models.enums import UserFrom
 from models.model import App, Conversation, Message, MessageAnnotation
 from models.workflow import ConversationVariable
 from services.conversation_variable_updater import ConversationVariableUpdater
@@ -106,6 +105,11 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
         if not app_record:
             raise ValueError("App not found")
 
+        invoke_from = self.application_generate_entity.invoke_from
+        if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
+            invoke_from = InvokeFrom.DEBUGGER
+        user_from = self._resolve_user_from(invoke_from)
+
         if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
             # Handle single iteration or single loop run
             graph, variable_pool, graph_runtime_state = self._prepare_single_node_execution(
@@ -158,6 +162,8 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
                 workflow_id=self._workflow.id,
                 tenant_id=self._workflow.tenant_id,
                 user_id=self.application_generate_entity.user_id,
+                user_from=user_from,
+                invoke_from=invoke_from,
             )
 
         db.session.close()
@@ -175,12 +181,8 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
             graph=graph,
             graph_config=self._workflow.graph_dict,
             user_id=self.application_generate_entity.user_id,
-            user_from=(
-                UserFrom.ACCOUNT
-                if self.application_generate_entity.invoke_from in {InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER}
-                else UserFrom.END_USER
-            ),
-            invoke_from=self.application_generate_entity.invoke_from,
+            user_from=user_from,
+            invoke_from=invoke_from,
             call_depth=self.application_generate_entity.call_depth,
             variable_pool=variable_pool,
             graph_runtime_state=graph_runtime_state,

api/core/app/apps/advanced_chat/generate_task_pipeline.py

@@ -4,7 +4,6 @@ import re
 import time
 from collections.abc import Callable, Generator, Mapping
 from contextlib import contextmanager
-from dataclasses import dataclass, field
 from threading import Thread
 from typing import Any, Union
 
@@ -20,7 +19,6 @@ from core.app.entities.app_invoke_entities import (
     InvokeFrom,
 )
 from core.app.entities.queue_entities import (
-    ChunkType,
     MessageQueueMessage,
     QueueAdvancedChatMessageEndEvent,
     QueueAgentLogEvent,
@@ -72,122 +70,13 @@ from core.workflow.runtime import GraphRuntimeState
 from core.workflow.system_variable import SystemVariable
 from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
-from models import Account, Conversation, EndUser, LLMGenerationDetail, Message, MessageFile
+from models import Account, Conversation, EndUser, Message, MessageFile
 from models.enums import CreatorUserRole
 from models.workflow import Workflow
 
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class StreamEventBuffer:
-    """
-    Buffer for recording stream events in order to reconstruct the generation sequence.
-    Records the exact order of text chunks, thoughts, and tool calls as they stream.
-    """
-
-    # Accumulated reasoning content (each thought block is a separate element)
-    reasoning_content: list[str] = field(default_factory=list)
-    # Current reasoning buffer (accumulates until we see a different event type)
-    _current_reasoning: str = ""
-    # Tool calls with their details
-    tool_calls: list[dict] = field(default_factory=list)
-    # Tool call ID to index mapping for updating results
-    _tool_call_id_map: dict[str, int] = field(default_factory=dict)
-    # Sequence of events in stream order
-    sequence: list[dict] = field(default_factory=list)
-    # Current position in answer text
-    _content_position: int = 0
-    # Track last event type to detect transitions
-    _last_event_type: str | None = None
-
-    def _flush_current_reasoning(self) -> None:
-        """Flush accumulated reasoning to the list and add to sequence."""
-        if self._current_reasoning.strip():
-            self.reasoning_content.append(self._current_reasoning.strip())
-            self.sequence.append({"type": "reasoning", "index": len(self.reasoning_content) - 1})
-            self._current_reasoning = ""
-
-    def record_text_chunk(self, text: str) -> None:
-        """Record a text chunk event."""
-        if not text:
-            return
-
-        # Flush any pending reasoning first
-        if self._last_event_type == "thought":
-            self._flush_current_reasoning()
-
-        text_len = len(text)
-        start_pos = self._content_position
-
-        # If last event was also content, extend it; otherwise create new
-        if self.sequence and self.sequence[-1].get("type") == "content":
-            self.sequence[-1]["end"] = start_pos + text_len
-        else:
-            self.sequence.append({"type": "content", "start": start_pos, "end": start_pos + text_len})
-
-        self._content_position += text_len
-        self._last_event_type = "content"
-
-    def record_thought_chunk(self, text: str) -> None:
-        """Record a thought/reasoning chunk event."""
-        if not text:
-            return
-
-        # Accumulate thought content
-        self._current_reasoning += text
-        self._last_event_type = "thought"
-
-    def record_tool_call(self, tool_call_id: str, tool_name: str, tool_arguments: str) -> None:
-        """Record a tool call event."""
-        if not tool_call_id:
-            return
-
-        # Flush any pending reasoning first
-        if self._last_event_type == "thought":
-            self._flush_current_reasoning()
-
-        # Check if this tool call already exists (we might get multiple chunks)
-        if tool_call_id in self._tool_call_id_map:
-            idx = self._tool_call_id_map[tool_call_id]
-            # Update arguments if provided
-            if tool_arguments:
-                self.tool_calls[idx]["arguments"] = tool_arguments
-        else:
-            # New tool call
-            tool_call = {
-                "id": tool_call_id or "",
-                "name": tool_name or "",
-                "arguments": tool_arguments or "",
-                "result": "",
-                "elapsed_time": None,
-            }
-            self.tool_calls.append(tool_call)
-            idx = len(self.tool_calls) - 1
-            self._tool_call_id_map[tool_call_id] = idx
-            self.sequence.append({"type": "tool_call", "index": idx})
-
-        self._last_event_type = "tool_call"
-
-    def record_tool_result(self, tool_call_id: str, result: str, tool_elapsed_time: float | None = None) -> None:
-        """Record a tool result event (update existing tool call)."""
-        if not tool_call_id:
-            return
-        if tool_call_id in self._tool_call_id_map:
-            idx = self._tool_call_id_map[tool_call_id]
-            self.tool_calls[idx]["result"] = result
-            self.tool_calls[idx]["elapsed_time"] = tool_elapsed_time
-
-    def finalize(self) -> None:
-        """Finalize the buffer, flushing any pending data."""
-        if self._last_event_type == "thought":
-            self._flush_current_reasoning()
-
-    def has_data(self) -> bool:
-        """Check if there's any meaningful data recorded."""
-        return bool(self.reasoning_content or self.tool_calls or self.sequence)
-
-
 class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
     """
     AdvancedChatAppGenerateTaskPipeline is a class that generate stream output and state management for Application.
@@ -255,8 +144,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         self._workflow_run_id: str = ""
         self._draft_var_saver_factory = draft_var_saver_factory
         self._graph_runtime_state: GraphRuntimeState | None = None
-        # Stream event buffer for recording generation sequence
-        self._stream_buffer = StreamEventBuffer()
         self._seed_graph_runtime_state_from_queue_manager()
 
     def process(self) -> Union[ChatbotAppBlockingResponse, Generator[ChatbotAppStreamResponse, None, None]]:
@@ -515,7 +402,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         queue_message: Union[WorkflowQueueMessage, MessageQueueMessage] | None = None,
         **kwargs,
     ) -> Generator[StreamResponse, None, None]:
-        """Handle text chunk events and record to stream buffer for sequence reconstruction."""
+        """Handle text chunk events."""
         delta_text = event.text
         if delta_text is None:
             return
@@ -537,52 +424,9 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         if tts_publisher and queue_message:
             tts_publisher.publish(queue_message)
 
-        tool_call = event.tool_call
-        tool_result = event.tool_result
-        tool_payload = tool_call or tool_result
-        tool_call_id = tool_payload.id if tool_payload and tool_payload.id else ""
-        tool_name = tool_payload.name if tool_payload and tool_payload.name else ""
-        tool_arguments = tool_call.arguments if tool_call and tool_call.arguments else ""
-        tool_files = tool_result.files if tool_result else []
-        tool_elapsed_time = tool_result.elapsed_time if tool_result else None
-        tool_icon = tool_payload.icon if tool_payload else None
-        tool_icon_dark = tool_payload.icon_dark if tool_payload else None
-        # Record stream event based on chunk type
-        chunk_type = event.chunk_type or ChunkType.TEXT
-        match chunk_type:
-            case ChunkType.TEXT:
-                self._stream_buffer.record_text_chunk(delta_text)
-                self._task_state.answer += delta_text
-            case ChunkType.THOUGHT:
-                # Reasoning should not be part of final answer text
-                self._stream_buffer.record_thought_chunk(delta_text)
-            case ChunkType.TOOL_CALL:
-                self._stream_buffer.record_tool_call(
-                    tool_call_id=tool_call_id,
-                    tool_name=tool_name,
-                    tool_arguments=tool_arguments,
-                )
-            case ChunkType.TOOL_RESULT:
-                self._stream_buffer.record_tool_result(
-                    tool_call_id=tool_call_id,
-                    result=delta_text,
-                    tool_elapsed_time=tool_elapsed_time,
-                )
-                self._task_state.answer += delta_text
-            case _:
-                pass
+        self._task_state.answer += delta_text
         yield self._message_cycle_manager.message_to_stream_response(
-            answer=delta_text,
-            message_id=self._message_id,
-            from_variable_selector=event.from_variable_selector,
-            chunk_type=event.chunk_type.value if event.chunk_type else None,
-            tool_call_id=tool_call_id or None,
-            tool_name=tool_name or None,
-            tool_arguments=tool_arguments or None,
-            tool_files=tool_files,
-            tool_elapsed_time=tool_elapsed_time,
-            tool_icon=tool_icon,
-            tool_icon_dark=tool_icon_dark,
+            answer=delta_text, message_id=self._message_id, from_variable_selector=event.from_variable_selector
         )
 
     def _handle_iteration_start_event(
@@ -950,7 +794,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
 
         # If there are assistant files, remove markdown image links from answer
         answer_text = self._task_state.answer
-        answer_text = self._strip_think_blocks(answer_text)
         if self._recorded_files:
             # Remove markdown image links since we're storing files separately
             answer_text = re.sub(r"!\[.*?\]\(.*?\)", "", answer_text).strip()
@@ -1002,54 +845,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         ]
         session.add_all(message_files)
 
-        # Save generation detail (reasoning/tool calls/sequence) from stream buffer
-        self._save_generation_detail(session=session, message=message)
-
-    @staticmethod
-    def _strip_think_blocks(text: str) -> str:
-        """Remove <think>...</think> blocks (including their content) from text."""
-        if not text or "<think" not in text.lower():
-            return text
-
-        clean_text = re.sub(r"<think[^>]*>.*?</think>", "", text, flags=re.IGNORECASE | re.DOTALL)
-        clean_text = re.sub(r"\n\s*\n", "\n\n", clean_text).strip()
-        return clean_text
-
-    def _save_generation_detail(self, *, session: Session, message: Message) -> None:
-        """
-        Save LLM generation detail for Chatflow using stream event buffer.
-        The buffer records the exact order of events as they streamed,
-        allowing accurate reconstruction of the generation sequence.
-        """
-        # Finalize the stream buffer to flush any pending data
-        self._stream_buffer.finalize()
-
-        # Only save if there's meaningful data
-        if not self._stream_buffer.has_data():
-            return
-
-        reasoning_content = self._stream_buffer.reasoning_content
-        tool_calls = self._stream_buffer.tool_calls
-        sequence = self._stream_buffer.sequence
-
-        # Check if generation detail already exists for this message
-        existing = session.query(LLMGenerationDetail).filter_by(message_id=message.id).first()
-
-        if existing:
-            existing.reasoning_content = json.dumps(reasoning_content) if reasoning_content else None
-            existing.tool_calls = json.dumps(tool_calls) if tool_calls else None
-            existing.sequence = json.dumps(sequence) if sequence else None
-        else:
-            generation_detail = LLMGenerationDetail(
-                tenant_id=self._application_generate_entity.app_config.tenant_id,
-                app_id=self._application_generate_entity.app_config.app_id,
-                message_id=message.id,
-                reasoning_content=json.dumps(reasoning_content) if reasoning_content else None,
-                tool_calls=json.dumps(tool_calls) if tool_calls else None,
-                sequence=json.dumps(sequence) if sequence else None,
-            )
-            session.add(generation_detail)
-
     def _seed_graph_runtime_state_from_queue_manager(self) -> None:
         """Bootstrap the cached runtime state from the queue manager when present."""
         candidate = self._base_task_pipeline.queue_manager.graph_runtime_state

api/core/app/apps/agent_chat/app_runner.py

@@ -3,8 +3,10 @@ from typing import cast
 
 from sqlalchemy import select
 
-from core.agent.agent_app_runner import AgentAppRunner
+from core.agent.cot_chat_agent_runner import CotChatAgentRunner
+from core.agent.cot_completion_agent_runner import CotCompletionAgentRunner
 from core.agent.entities import AgentEntity
+from core.agent.fc_agent_runner import FunctionCallAgentRunner
 from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
 from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
 from core.app.apps.base_app_runner import AppRunner
@@ -12,7 +14,8 @@ from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity
 from core.app.entities.queue_entities import QueueAnnotationReplyEvent
 from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance
-from core.model_runtime.entities.model_entities import ModelFeature
+from core.model_runtime.entities.llm_entities import LLMMode
+from core.model_runtime.entities.model_entities import ModelFeature, ModelPropertyKey
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
 from core.moderation.base import ModerationError
 from extensions.ext_database import db
@@ -191,7 +194,22 @@ class AgentChatAppRunner(AppRunner):
             raise ValueError("Message not found")
         db.session.close()
 
-        runner = AgentAppRunner(
+        runner_cls: type[FunctionCallAgentRunner] | type[CotChatAgentRunner] | type[CotCompletionAgentRunner]
+        # start agent runner
+        if agent_entity.strategy == AgentEntity.Strategy.CHAIN_OF_THOUGHT:
+            # check LLM mode
+            if model_schema.model_properties.get(ModelPropertyKey.MODE) == LLMMode.CHAT:
+                runner_cls = CotChatAgentRunner
+            elif model_schema.model_properties.get(ModelPropertyKey.MODE) == LLMMode.COMPLETION:
+                runner_cls = CotCompletionAgentRunner
+            else:
+                raise ValueError(f"Invalid LLM mode: {model_schema.model_properties.get(ModelPropertyKey.MODE)}")
+        elif agent_entity.strategy == AgentEntity.Strategy.FUNCTION_CALLING:
+            runner_cls = FunctionCallAgentRunner
+        else:
+            raise ValueError(f"Invalid agent strategy: {agent_entity.strategy}")
+
+        runner = runner_cls(
             tenant_id=app_config.tenant_id,
             application_generate_entity=application_generate_entity,
             conversation=conversation_result,

api/core/app/apps/common/workflow_response_converter.py

@@ -671,7 +671,7 @@ class WorkflowResponseConverter:
             task_id=task_id,
             data=AgentLogStreamResponse.Data(
                 node_execution_id=event.node_execution_id,
-                message_id=event.id,
+                id=event.id,
                 parent_id=event.parent_id,
                 label=event.label,
                 error=event.error,

api/core/app/apps/pipeline/pipeline_runner.py

@@ -73,9 +73,15 @@ class PipelineRunner(WorkflowBasedAppRunner):
         """
         app_config = self.application_generate_entity.app_config
         app_config = cast(PipelineConfig, app_config)
+        invoke_from = self.application_generate_entity.invoke_from
+
+        if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
+            invoke_from = InvokeFrom.DEBUGGER
+
+        user_from = self._resolve_user_from(invoke_from)
 
         user_id = None
-        if self.application_generate_entity.invoke_from in {InvokeFrom.WEB_APP, InvokeFrom.SERVICE_API}:
+        if invoke_from in {InvokeFrom.WEB_APP, InvokeFrom.SERVICE_API}:
             end_user = db.session.query(EndUser).where(EndUser.id == self.application_generate_entity.user_id).first()
             if end_user:
                 user_id = end_user.session_id
@@ -117,7 +123,7 @@ class PipelineRunner(WorkflowBasedAppRunner):
                 dataset_id=self.application_generate_entity.dataset_id,
                 datasource_type=self.application_generate_entity.datasource_type,
                 datasource_info=self.application_generate_entity.datasource_info,
-                invoke_from=self.application_generate_entity.invoke_from.value,
+                invoke_from=invoke_from.value,
             )
 
             rag_pipeline_variables = []
@@ -149,6 +155,8 @@ class PipelineRunner(WorkflowBasedAppRunner):
                 graph_runtime_state=graph_runtime_state,
                 start_node_id=self.application_generate_entity.start_node_id,
                 workflow=workflow,
+                user_from=user_from,
+                invoke_from=invoke_from,
             )
 
         # RUN WORKFLOW
@@ -159,12 +167,8 @@ class PipelineRunner(WorkflowBasedAppRunner):
             graph=graph,
             graph_config=workflow.graph_dict,
             user_id=self.application_generate_entity.user_id,
-            user_from=(
-                UserFrom.ACCOUNT
-                if self.application_generate_entity.invoke_from in {InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER}
-                else UserFrom.END_USER
-            ),
-            invoke_from=self.application_generate_entity.invoke_from,
+            user_from=user_from,
+            invoke_from=invoke_from,
             call_depth=self.application_generate_entity.call_depth,
             graph_runtime_state=graph_runtime_state,
             variable_pool=variable_pool,
@@ -210,7 +214,12 @@ class PipelineRunner(WorkflowBasedAppRunner):
         return workflow
 
     def _init_rag_pipeline_graph(
-        self, workflow: Workflow, graph_runtime_state: GraphRuntimeState, start_node_id: str | None = None
+        self,
+        workflow: Workflow,
+        graph_runtime_state: GraphRuntimeState,
+        start_node_id: str | None = None,
+        user_from: UserFrom = UserFrom.ACCOUNT,
+        invoke_from: InvokeFrom = InvokeFrom.SERVICE_API,
     ) -> Graph:
         """
         Init pipeline graph
@@ -253,8 +262,8 @@ class PipelineRunner(WorkflowBasedAppRunner):
             workflow_id=workflow.id,
             graph_config=graph_config,
             user_id=self.application_generate_entity.user_id,
-            user_from=UserFrom.ACCOUNT,
-            invoke_from=InvokeFrom.SERVICE_API,
+            user_from=user_from,
+            invoke_from=invoke_from,
             call_depth=0,
         )
 

api/core/app/apps/workflow/app_runner.py

@@ -20,7 +20,6 @@ from core.workflow.workflow_entry import WorkflowEntry
 from extensions.ext_redis import redis_client
 from extensions.otel import WorkflowAppRunnerHandler, trace_span
 from libs.datetime_utils import naive_utc_now
-from models.enums import UserFrom
 from models.workflow import Workflow
 
 logger = logging.getLogger(__name__)
@@ -74,7 +73,12 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
             workflow_execution_id=self.application_generate_entity.workflow_execution_id,
         )
 
+        invoke_from = self.application_generate_entity.invoke_from
         # if only single iteration or single loop run is requested
+        if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
+            invoke_from = InvokeFrom.DEBUGGER
+        user_from = self._resolve_user_from(invoke_from)
+
         if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
             graph, variable_pool, graph_runtime_state = self._prepare_single_node_execution(
                 workflow=self._workflow,
@@ -102,6 +106,8 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
                 workflow_id=self._workflow.id,
                 tenant_id=self._workflow.tenant_id,
                 user_id=self.application_generate_entity.user_id,
+                user_from=user_from,
+                invoke_from=invoke_from,
                 root_node_id=self._root_node_id,
             )
 
@@ -120,12 +126,8 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
             graph=graph,
             graph_config=self._workflow.graph_dict,
             user_id=self.application_generate_entity.user_id,
-            user_from=(
-                UserFrom.ACCOUNT
-                if self.application_generate_entity.invoke_from in {InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER}
-                else UserFrom.END_USER
-            ),
-            invoke_from=self.application_generate_entity.invoke_from,
+            user_from=user_from,
+            invoke_from=invoke_from,
             call_depth=self.application_generate_entity.call_depth,
             variable_pool=variable_pool,
             graph_runtime_state=graph_runtime_state,

api/core/app/apps/workflow/generate_task_pipeline.py

@@ -13,7 +13,6 @@ from core.app.apps.common.workflow_response_converter import WorkflowResponseCon
 from core.app.entities.app_invoke_entities import InvokeFrom, WorkflowAppGenerateEntity
 from core.app.entities.queue_entities import (
     AppQueueEvent,
-    ChunkType,
     MessageQueueMessage,
     QueueAgentLogEvent,
     QueueErrorEvent,
@@ -484,33 +483,11 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         if delta_text is None:
             return
 
-        tool_call = event.tool_call
-        tool_result = event.tool_result
-        tool_payload = tool_call or tool_result
-        tool_call_id = tool_payload.id if tool_payload and tool_payload.id else None
-        tool_name = tool_payload.name if tool_payload and tool_payload.name else None
-        tool_arguments = tool_call.arguments if tool_call else None
-        tool_elapsed_time = tool_result.elapsed_time if tool_result else None
-        tool_files = tool_result.files if tool_result else []
-        tool_icon = tool_payload.icon if tool_payload else None
-        tool_icon_dark = tool_payload.icon_dark if tool_payload else None
-
         # only publish tts message at text chunk streaming
         if tts_publisher and queue_message:
             tts_publisher.publish(queue_message)
 
-        yield self._text_chunk_to_stream_response(
-            text=delta_text,
-            from_variable_selector=event.from_variable_selector,
-            chunk_type=event.chunk_type,
-            tool_call_id=tool_call_id,
-            tool_name=tool_name,
-            tool_arguments=tool_arguments,
-            tool_files=tool_files,
-            tool_elapsed_time=tool_elapsed_time,
-            tool_icon=tool_icon,
-            tool_icon_dark=tool_icon_dark,
-        )
+        yield self._text_chunk_to_stream_response(delta_text, from_variable_selector=event.from_variable_selector)
 
     def _handle_agent_log_event(self, event: QueueAgentLogEvent, **kwargs) -> Generator[StreamResponse, None, None]:
         """Handle agent log events."""
@@ -673,61 +650,16 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         session.add(workflow_app_log)
 
     def _text_chunk_to_stream_response(
-        self,
-        text: str,
-        from_variable_selector: list[str] | None = None,
-        chunk_type: ChunkType | None = None,
-        tool_call_id: str | None = None,
-        tool_name: str | None = None,
-        tool_arguments: str | None = None,
-        tool_files: list[str] | None = None,
-        tool_error: str | None = None,
-        tool_elapsed_time: float | None = None,
-        tool_icon: str | dict | None = None,
-        tool_icon_dark: str | dict | None = None,
+        self, text: str, from_variable_selector: list[str] | None = None
     ) -> TextChunkStreamResponse:
         """
         Handle completed event.
         :param text: text
         :return:
         """
-        from core.app.entities.task_entities import ChunkType as ResponseChunkType
-
-        response_chunk_type = ResponseChunkType(chunk_type.value) if chunk_type else ResponseChunkType.TEXT
-
-        data = TextChunkStreamResponse.Data(
-            text=text,
-            from_variable_selector=from_variable_selector,
-            chunk_type=response_chunk_type,
-        )
-
-        if response_chunk_type == ResponseChunkType.TOOL_CALL:
-            data = data.model_copy(
-                update={
-                    "tool_call_id": tool_call_id,
-                    "tool_name": tool_name,
-                    "tool_arguments": tool_arguments,
-                    "tool_icon": tool_icon,
-                    "tool_icon_dark": tool_icon_dark,
-                }
-            )
-        elif response_chunk_type == ResponseChunkType.TOOL_RESULT:
-            data = data.model_copy(
-                update={
-                    "tool_call_id": tool_call_id,
-                    "tool_name": tool_name,
-                    "tool_arguments": tool_arguments,
-                    "tool_files": tool_files,
-                    "tool_error": tool_error,
-                    "tool_elapsed_time": tool_elapsed_time,
-                    "tool_icon": tool_icon,
-                    "tool_icon_dark": tool_icon_dark,
-                }
-            )
-
         response = TextChunkStreamResponse(
             task_id=self._application_generate_entity.task_id,
-            data=data,
+            data=TextChunkStreamResponse.Data(text=text, from_variable_selector=from_variable_selector),
         )
 
         return response

api/core/app/apps/workflow_app_runner.py

@@ -77,10 +77,18 @@ class WorkflowBasedAppRunner:
         self._app_id = app_id
         self._graph_engine_layers = graph_engine_layers
 
+    @staticmethod
+    def _resolve_user_from(invoke_from: InvokeFrom) -> UserFrom:
+        if invoke_from in {InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER}:
+            return UserFrom.ACCOUNT
+        return UserFrom.END_USER
+
     def _init_graph(
         self,
         graph_config: Mapping[str, Any],
         graph_runtime_state: GraphRuntimeState,
+        user_from: UserFrom,
+        invoke_from: InvokeFrom,
         workflow_id: str = "",
         tenant_id: str = "",
         user_id: str = "",
@@ -105,8 +113,8 @@ class WorkflowBasedAppRunner:
             workflow_id=workflow_id,
             graph_config=graph_config,
             user_id=user_id,
-            user_from=UserFrom.ACCOUNT,
-            invoke_from=InvokeFrom.SERVICE_API,
+            user_from=user_from,
+            invoke_from=invoke_from,
             call_depth=0,
         )
 
@@ -250,7 +258,7 @@ class WorkflowBasedAppRunner:
             graph_config=graph_config,
             user_id="",
             user_from=UserFrom.ACCOUNT,
-            invoke_from=InvokeFrom.SERVICE_API,
+            invoke_from=InvokeFrom.DEBUGGER,
             call_depth=0,
         )
 
@@ -455,20 +463,12 @@ class WorkflowBasedAppRunner:
                 )
             )
         elif isinstance(event, NodeRunStreamChunkEvent):
-            from core.app.entities.queue_entities import ChunkType as QueueChunkType
-
-            if event.is_final and not event.chunk:
-                return
-
             self._publish_event(
                 QueueTextChunkEvent(
                     text=event.chunk,
                     from_variable_selector=list(event.selector),
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    chunk_type=QueueChunkType(event.chunk_type.value),
-                    tool_call=event.tool_call,
-                    tool_result=event.tool_result,
                 )
             )
         elif isinstance(event, NodeRunRetrieverResourceEvent):

api/core/app/entities/llm_generation_entities.py

@@ -1,70 +0,0 @@
-"""
-LLM Generation Detail entities.
-
-Defines the structure for storing and transmitting LLM generation details
-including reasoning content, tool calls, and their sequence.
-"""
-
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-
-class ContentSegment(BaseModel):
-    """Represents a content segment in the generation sequence."""
-
-    type: Literal["content"] = "content"
-    start: int = Field(..., description="Start position in the text")
-    end: int = Field(..., description="End position in the text")
-
-
-class ReasoningSegment(BaseModel):
-    """Represents a reasoning segment in the generation sequence."""
-
-    type: Literal["reasoning"] = "reasoning"
-    index: int = Field(..., description="Index into reasoning_content array")
-
-
-class ToolCallSegment(BaseModel):
-    """Represents a tool call segment in the generation sequence."""
-
-    type: Literal["tool_call"] = "tool_call"
-    index: int = Field(..., description="Index into tool_calls array")
-
-
-SequenceSegment = ContentSegment | ReasoningSegment | ToolCallSegment
-
-
-class ToolCallDetail(BaseModel):
-    """Represents a tool call with its arguments and result."""
-
-    id: str = Field(default="", description="Unique identifier for the tool call")
-    name: str = Field(..., description="Name of the tool")
-    arguments: str = Field(default="", description="JSON string of tool arguments")
-    result: str = Field(default="", description="Result from the tool execution")
-    elapsed_time: float | None = Field(default=None, description="Elapsed time in seconds")
-
-
-class LLMGenerationDetailData(BaseModel):
-    """
-    Domain model for LLM generation detail.
-
-    Contains the structured data for reasoning content, tool calls,
-    and their display sequence.
-    """
-
-    reasoning_content: list[str] = Field(default_factory=list, description="List of reasoning segments")
-    tool_calls: list[ToolCallDetail] = Field(default_factory=list, description="List of tool call details")
-    sequence: list[SequenceSegment] = Field(default_factory=list, description="Display order of segments")
-
-    def is_empty(self) -> bool:
-        """Check if there's any meaningful generation detail."""
-        return not self.reasoning_content and not self.tool_calls
-
-    def to_response_dict(self) -> dict:
-        """Convert to dictionary for API response."""
-        return {
-            "reasoning_content": self.reasoning_content,
-            "tool_calls": [tc.model_dump() for tc in self.tool_calls],
-            "sequence": [seg.model_dump() for seg in self.sequence],
-        }

api/core/app/entities/queue_entities.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 from core.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
-from core.workflow.entities import AgentNodeStrategyInit, ToolCall, ToolResult
+from core.workflow.entities import AgentNodeStrategyInit
 from core.workflow.enums import WorkflowNodeExecutionMetadataKey
 from core.workflow.nodes import NodeType
 
@@ -177,17 +177,6 @@ class QueueLoopCompletedEvent(AppQueueEvent):
     error: str | None = None
 
 
-class ChunkType(StrEnum):
-    """Stream chunk type for LLM-related events."""
-
-    TEXT = "text"  # Normal text streaming
-    TOOL_CALL = "tool_call"  # Tool call arguments streaming
-    TOOL_RESULT = "tool_result"  # Tool execution result
-    THOUGHT = "thought"  # Agent thinking process (ReAct)
-    THOUGHT_START = "thought_start"  # Agent thought start
-    THOUGHT_END = "thought_end"  # Agent thought end
-
-
 class QueueTextChunkEvent(AppQueueEvent):
     """
     QueueTextChunkEvent entity
@@ -202,16 +191,6 @@ class QueueTextChunkEvent(AppQueueEvent):
     in_loop_id: str | None = None
     """loop id if node is in loop"""
 
-    # Extended fields for Agent/Tool streaming
-    chunk_type: ChunkType = ChunkType.TEXT
-    """type of the chunk"""
-
-    # Tool streaming payloads
-    tool_call: ToolCall | None = None
-    """structured tool call info"""
-    tool_result: ToolResult | None = None
-    """structured tool result info"""
-
 
 class QueueAgentMessageEvent(AppQueueEvent):
     """

api/core/app/entities/task_entities.py

@@ -113,38 +113,6 @@ class MessageStreamResponse(StreamResponse):
     answer: str
     from_variable_selector: list[str] | None = None
 
-    # Extended fields for Agent/Tool streaming (imported at runtime to avoid circular import)
-    chunk_type: str | None = None
-    """type of the chunk: text, tool_call, tool_result, thought"""
-
-    # Tool call fields (when chunk_type == "tool_call")
-    tool_call_id: str | None = None
-    """unique identifier for this tool call"""
-    tool_name: str | None = None
-    """name of the tool being called"""
-    tool_arguments: str | None = None
-    """accumulated tool arguments JSON"""
-
-    # Tool result fields (when chunk_type == "tool_result")
-    tool_files: list[str] | None = None
-    """file IDs produced by tool"""
-    tool_error: str | None = None
-    """error message if tool failed"""
-    tool_elapsed_time: float | None = None
-    """elapsed time spent executing the tool"""
-    tool_icon: str | dict | None = None
-    """icon of the tool"""
-    tool_icon_dark: str | dict | None = None
-    """dark theme icon of the tool"""
-
-    def model_dump(self, *args, **kwargs) -> dict[str, object]:
-        kwargs.setdefault("exclude_none", True)
-        return super().model_dump(*args, **kwargs)
-
-    def model_dump_json(self, *args, **kwargs) -> str:
-        kwargs.setdefault("exclude_none", True)
-        return super().model_dump_json(*args, **kwargs)
-
 
 class MessageAudioStreamResponse(StreamResponse):
     """
@@ -614,17 +582,6 @@ class LoopNodeCompletedStreamResponse(StreamResponse):
     data: Data
 
 
-class ChunkType(StrEnum):
-    """Stream chunk type for LLM-related events."""
-
-    TEXT = "text"  # Normal text streaming
-    TOOL_CALL = "tool_call"  # Tool call arguments streaming
-    TOOL_RESULT = "tool_result"  # Tool execution result
-    THOUGHT = "thought"  # Agent thinking process (ReAct)
-    THOUGHT_START = "thought_start"  # Agent thought start
-    THOUGHT_END = "thought_end"  # Agent thought end
-
-
 class TextChunkStreamResponse(StreamResponse):
     """
     TextChunkStreamResponse entity
@@ -638,36 +595,6 @@ class TextChunkStreamResponse(StreamResponse):
         text: str
         from_variable_selector: list[str] | None = None
 
-        # Extended fields for Agent/Tool streaming
-        chunk_type: ChunkType = ChunkType.TEXT
-        """type of the chunk"""
-
-        # Tool call fields (when chunk_type == TOOL_CALL)
-        tool_call_id: str | None = None
-        """unique identifier for this tool call"""
-        tool_name: str | None = None
-        """name of the tool being called"""
-        tool_arguments: str | None = None
-        """accumulated tool arguments JSON"""
-
-        # Tool result fields (when chunk_type == TOOL_RESULT)
-        tool_files: list[str] | None = None
-        """file IDs produced by tool"""
-        tool_error: str | None = None
-        """error message if tool failed"""
-
-        # Tool elapsed time fields (when chunk_type == TOOL_RESULT)
-        tool_elapsed_time: float | None = None
-        """elapsed time spent executing the tool"""
-
-        def model_dump(self, *args, **kwargs) -> dict[str, object]:
-            kwargs.setdefault("exclude_none", True)
-            return super().model_dump(*args, **kwargs)
-
-        def model_dump_json(self, *args, **kwargs) -> str:
-            kwargs.setdefault("exclude_none", True)
-            return super().model_dump_json(*args, **kwargs)
-
     event: StreamEvent = StreamEvent.TEXT_CHUNK
     data: Data
 
@@ -816,7 +743,7 @@ class AgentLogStreamResponse(StreamResponse):
         """
 
         node_execution_id: str
-        message_id: str
+        id: str
         label: str
         parent_id: str | None = None
         error: str | None = None

api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py

@@ -1,5 +1,4 @@
 import logging
-import re
 import time
 from collections.abc import Generator
 from threading import Thread
@@ -59,7 +58,7 @@ from core.prompt.utils.prompt_template_parser import PromptTemplateParser
 from events.message_event import message_was_created
 from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
-from models.model import AppMode, Conversation, LLMGenerationDetail, Message, MessageAgentThought
+from models.model import AppMode, Conversation, Message, MessageAgentThought
 
 logger = logging.getLogger(__name__)
 
@@ -69,8 +68,6 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
     EasyUIBasedGenerateTaskPipeline is a class that generate stream output and state management for Application.
     """
 
-    _THINK_PATTERN = re.compile(r"<think[^>]*>(.*?)</think>", re.IGNORECASE | re.DOTALL)
-
     _task_state: EasyUITaskState
     _application_generate_entity: Union[ChatAppGenerateEntity, CompletionAppGenerateEntity, AgentChatAppGenerateEntity]
 
@@ -412,136 +409,11 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
                 )
             )
 
-        # Save LLM generation detail if there's reasoning_content
-        self._save_generation_detail(session=session, message=message, llm_result=llm_result)
-
         message_was_created.send(
             message,
             application_generate_entity=self._application_generate_entity,
         )
 
-    def _save_generation_detail(self, *, session: Session, message: Message, llm_result: LLMResult) -> None:
-        """
-        Save LLM generation detail for Completion/Chat/Agent-Chat applications.
-        For Agent-Chat, also merges MessageAgentThought records.
-        """
-        import json
-
-        reasoning_list: list[str] = []
-        tool_calls_list: list[dict] = []
-        sequence: list[dict] = []
-        answer = message.answer or ""
-
-        # Check if this is Agent-Chat mode by looking for agent thoughts
-        agent_thoughts = (
-            session.query(MessageAgentThought)
-            .filter_by(message_id=message.id)
-            .order_by(MessageAgentThought.position.asc())
-            .all()
-        )
-
-        if agent_thoughts:
-            # Agent-Chat mode: merge MessageAgentThought records
-            content_pos = 0
-            cleaned_answer_parts: list[str] = []
-            for thought in agent_thoughts:
-                # Add thought/reasoning
-                if thought.thought:
-                    reasoning_text = thought.thought
-                    if "<think" in reasoning_text.lower():
-                        clean_text, extracted_reasoning = self._split_reasoning_from_answer(reasoning_text)
-                        if extracted_reasoning:
-                            reasoning_text = extracted_reasoning
-                            thought.thought = clean_text or extracted_reasoning
-                    reasoning_list.append(reasoning_text)
-                    sequence.append({"type": "reasoning", "index": len(reasoning_list) - 1})
-
-                # Add tool calls
-                if thought.tool:
-                    tool_calls_list.append(
-                        {
-                            "name": thought.tool,
-                            "arguments": thought.tool_input or "",
-                            "result": thought.observation or "",
-                        }
-                    )
-                    sequence.append({"type": "tool_call", "index": len(tool_calls_list) - 1})
-
-                # Add answer content if present
-                if thought.answer:
-                    content_text = thought.answer
-                    if "<think" in content_text.lower():
-                        clean_answer, extracted_reasoning = self._split_reasoning_from_answer(content_text)
-                        if extracted_reasoning:
-                            reasoning_list.append(extracted_reasoning)
-                            sequence.append({"type": "reasoning", "index": len(reasoning_list) - 1})
-                        content_text = clean_answer
-                        thought.answer = clean_answer or content_text
-
-                    if content_text:
-                        start = content_pos
-                        end = content_pos + len(content_text)
-                        sequence.append({"type": "content", "start": start, "end": end})
-                        content_pos = end
-                        cleaned_answer_parts.append(content_text)
-
-            if cleaned_answer_parts:
-                merged_answer = "".join(cleaned_answer_parts)
-                message.answer = merged_answer
-                llm_result.message.content = merged_answer
-        else:
-            # Completion/Chat mode: use reasoning_content from llm_result
-            reasoning_content = llm_result.reasoning_content
-            if not reasoning_content and answer:
-                # Extract reasoning from <think> blocks and clean the final answer
-                clean_answer, reasoning_content = self._split_reasoning_from_answer(answer)
-                if reasoning_content:
-                    answer = clean_answer
-                    llm_result.message.content = clean_answer
-                    llm_result.reasoning_content = reasoning_content
-                    message.answer = clean_answer
-            if reasoning_content:
-                reasoning_list = [reasoning_content]
-                # Content comes first, then reasoning
-                if answer:
-                    sequence.append({"type": "content", "start": 0, "end": len(answer)})
-                sequence.append({"type": "reasoning", "index": 0})
-
-        # Only save if there's meaningful generation detail
-        if not reasoning_list and not tool_calls_list:
-            return
-
-        # Check if generation detail already exists
-        existing = session.query(LLMGenerationDetail).filter_by(message_id=message.id).first()
-
-        if existing:
-            existing.reasoning_content = json.dumps(reasoning_list) if reasoning_list else None
-            existing.tool_calls = json.dumps(tool_calls_list) if tool_calls_list else None
-            existing.sequence = json.dumps(sequence) if sequence else None
-        else:
-            generation_detail = LLMGenerationDetail(
-                tenant_id=self._application_generate_entity.app_config.tenant_id,
-                app_id=self._application_generate_entity.app_config.app_id,
-                message_id=message.id,
-                reasoning_content=json.dumps(reasoning_list) if reasoning_list else None,
-                tool_calls=json.dumps(tool_calls_list) if tool_calls_list else None,
-                sequence=json.dumps(sequence) if sequence else None,
-            )
-            session.add(generation_detail)
-
-    @classmethod
-    def _split_reasoning_from_answer(cls, text: str) -> tuple[str, str]:
-        """
-        Extract reasoning segments from <think> blocks and return (clean_text, reasoning).
-        """
-        matches = cls._THINK_PATTERN.findall(text)
-        reasoning_content = "\n".join(match.strip() for match in matches) if matches else ""
-
-        clean_text = cls._THINK_PATTERN.sub("", text)
-        clean_text = re.sub(r"\n\s*\n", "\n\n", clean_text).strip()
-
-        return clean_text, reasoning_content or ""
-
     def _handle_stop(self, event: QueueStopEvent):
         """
         Handle stop.

api/core/app/task_pipeline/message_cycle_manager.py

@@ -232,31 +232,15 @@ class MessageCycleManager:
         answer: str,
         message_id: str,
         from_variable_selector: list[str] | None = None,
-        chunk_type: str | None = None,
-        tool_call_id: str | None = None,
-        tool_name: str | None = None,
-        tool_arguments: str | None = None,
-        tool_files: list[str] | None = None,
-        tool_error: str | None = None,
-        tool_elapsed_time: float | None = None,
-        tool_icon: str | dict | None = None,
-        tool_icon_dark: str | dict | None = None,
         event_type: StreamEvent | None = None,
     ) -> MessageStreamResponse:
         """
         Message to stream response.
         :param answer: answer
         :param message_id: message id
-        :param from_variable_selector: from variable selector
-        :param chunk_type: type of the chunk (text, function_call, tool_result, thought)
-        :param tool_call_id: unique identifier for this tool call
-        :param tool_name: name of the tool being called
-        :param tool_arguments: accumulated tool arguments JSON
-        :param tool_files: file IDs produced by tool
-        :param tool_error: error message if tool failed
         :return:
         """
-        response = MessageStreamResponse(
+        return MessageStreamResponse(
             task_id=self._application_generate_entity.task_id,
             id=message_id,
             answer=answer,
@@ -264,35 +248,6 @@ class MessageCycleManager:
             event=event_type or StreamEvent.MESSAGE,
         )
 
-        if chunk_type:
-            response = response.model_copy(update={"chunk_type": chunk_type})
-
-        if chunk_type == "tool_call":
-            response = response.model_copy(
-                update={
-                    "tool_call_id": tool_call_id,
-                    "tool_name": tool_name,
-                    "tool_arguments": tool_arguments,
-                    "tool_icon": tool_icon,
-                    "tool_icon_dark": tool_icon_dark,
-                }
-            )
-        elif chunk_type == "tool_result":
-            response = response.model_copy(
-                update={
-                    "tool_call_id": tool_call_id,
-                    "tool_name": tool_name,
-                    "tool_arguments": tool_arguments,
-                    "tool_files": tool_files,
-                    "tool_error": tool_error,
-                    "tool_elapsed_time": tool_elapsed_time,
-                    "tool_icon": tool_icon,
-                    "tool_icon_dark": tool_icon_dark,
-                }
-            )
-
-        return response
-
     def message_replace_to_stream_response(self, answer: str, reason: str = "") -> MessageReplaceStreamResponse:
         """
         Message replace to stream response.

api/core/callback_handler/index_tool_callback_handler.py

@@ -5,6 +5,7 @@ from sqlalchemy import select
 
 from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.entities.queue_entities import QueueRetrieverResourcesEvent
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
 from core.rag.index_processor.constant.index_type import IndexStructureType
 from core.rag.models.document import Document
@@ -89,8 +90,6 @@ class DatasetIndexToolCallbackHandler:
     # TODO(-LAN-): Improve type check
     def return_retriever_resource_info(self, resource: Sequence[RetrievalSourceMetadata]):
         """Handle return_retriever_resource_info."""
-        from core.app.entities.queue_entities import QueueRetrieverResourcesEvent
-
         self._queue_manager.publish(
             QueueRetrieverResourcesEvent(retriever_resources=resource), PublishFrom.APPLICATION_MANAGER
         )

api/core/hosting_configuration.py

@@ -56,6 +56,10 @@ class HostingConfiguration:
         self.provider_map[f"{DEFAULT_PLUGIN_ID}/minimax/minimax"] = self.init_minimax()
         self.provider_map[f"{DEFAULT_PLUGIN_ID}/spark/spark"] = self.init_spark()
         self.provider_map[f"{DEFAULT_PLUGIN_ID}/zhipuai/zhipuai"] = self.init_zhipuai()
+        self.provider_map[f"{DEFAULT_PLUGIN_ID}/gemini/google"] = self.init_gemini()
+        self.provider_map[f"{DEFAULT_PLUGIN_ID}/x/x"] = self.init_xai()
+        self.provider_map[f"{DEFAULT_PLUGIN_ID}/deepseek/deepseek"] = self.init_deepseek()
+        self.provider_map[f"{DEFAULT_PLUGIN_ID}/tongyi/tongyi"] = self.init_tongyi()
 
         self.moderation_config = self.init_moderation_config()
 
@@ -128,7 +132,7 @@ class HostingConfiguration:
         quotas: list[HostingQuota] = []
 
         if dify_config.HOSTED_OPENAI_TRIAL_ENABLED:
-            hosted_quota_limit = dify_config.HOSTED_OPENAI_QUOTA_LIMIT
+            hosted_quota_limit = 0
             trial_models = self.parse_restrict_models_from_env("HOSTED_OPENAI_TRIAL_MODELS")
             trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit, restrict_models=trial_models)
             quotas.append(trial_quota)
@@ -156,18 +160,49 @@ class HostingConfiguration:
             quota_unit=quota_unit,
         )
 
-    @staticmethod
-    def init_anthropic() -> HostingProvider:
-        quota_unit = QuotaUnit.TOKENS
+    def init_gemini(self) -> HostingProvider:
+        quota_unit = QuotaUnit.CREDITS
+        quotas: list[HostingQuota] = []
+
+        if dify_config.HOSTED_GEMINI_TRIAL_ENABLED:
+            hosted_quota_limit = 0
+            trial_models = self.parse_restrict_models_from_env("HOSTED_GEMINI_TRIAL_MODELS")
+            trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit, restrict_models=trial_models)
+            quotas.append(trial_quota)
+
+        if dify_config.HOSTED_GEMINI_PAID_ENABLED:
+            paid_models = self.parse_restrict_models_from_env("HOSTED_GEMINI_PAID_MODELS")
+            paid_quota = PaidHostingQuota(restrict_models=paid_models)
+            quotas.append(paid_quota)
+
+        if len(quotas) > 0:
+            credentials = {
+                "google_api_key": dify_config.HOSTED_GEMINI_API_KEY,
+            }
+
+            if dify_config.HOSTED_GEMINI_API_BASE:
+                credentials["google_base_url"] = dify_config.HOSTED_GEMINI_API_BASE
+
+            return HostingProvider(enabled=True, credentials=credentials, quota_unit=quota_unit, quotas=quotas)
+
+        return HostingProvider(
+            enabled=False,
+            quota_unit=quota_unit,
+        )
+
+    def init_anthropic(self) -> HostingProvider:
+        quota_unit = QuotaUnit.CREDITS
         quotas: list[HostingQuota] = []
 
         if dify_config.HOSTED_ANTHROPIC_TRIAL_ENABLED:
-            hosted_quota_limit = dify_config.HOSTED_ANTHROPIC_QUOTA_LIMIT
-            trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit)
+            hosted_quota_limit = 0
+            trail_models = self.parse_restrict_models_from_env("HOSTED_ANTHROPIC_TRIAL_MODELS")
+            trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit, restrict_models=trail_models)
             quotas.append(trial_quota)
 
         if dify_config.HOSTED_ANTHROPIC_PAID_ENABLED:
-            paid_quota = PaidHostingQuota()
+            paid_models = self.parse_restrict_models_from_env("HOSTED_ANTHROPIC_PAID_MODELS")
+            paid_quota = PaidHostingQuota(restrict_models=paid_models)
             quotas.append(paid_quota)
 
         if len(quotas) > 0:
@@ -185,6 +220,94 @@ class HostingConfiguration:
             quota_unit=quota_unit,
         )
 
+    def init_tongyi(self) -> HostingProvider:
+        quota_unit = QuotaUnit.CREDITS
+        quotas: list[HostingQuota] = []
+
+        if dify_config.HOSTED_TONGYI_TRIAL_ENABLED:
+            hosted_quota_limit = 0
+            trail_models = self.parse_restrict_models_from_env("HOSTED_TONGYI_TRIAL_MODELS")
+            trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit, restrict_models=trail_models)
+            quotas.append(trial_quota)
+
+        if dify_config.HOSTED_TONGYI_PAID_ENABLED:
+            paid_models = self.parse_restrict_models_from_env("HOSTED_TONGYI_PAID_MODELS")
+            paid_quota = PaidHostingQuota(restrict_models=paid_models)
+            quotas.append(paid_quota)
+
+        if len(quotas) > 0:
+            credentials = {
+                "dashscope_api_key": dify_config.HOSTED_TONGYI_API_KEY,
+                "use_international_endpoint": dify_config.HOSTED_TONGYI_USE_INTERNATIONAL_ENDPOINT,
+            }
+
+            return HostingProvider(enabled=True, credentials=credentials, quota_unit=quota_unit, quotas=quotas)
+
+        return HostingProvider(
+            enabled=False,
+            quota_unit=quota_unit,
+        )
+
+    def init_xai(self) -> HostingProvider:
+        quota_unit = QuotaUnit.CREDITS
+        quotas: list[HostingQuota] = []
+
+        if dify_config.HOSTED_XAI_TRIAL_ENABLED:
+            hosted_quota_limit = 0
+            trail_models = self.parse_restrict_models_from_env("HOSTED_XAI_TRIAL_MODELS")
+            trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit, restrict_models=trail_models)
+            quotas.append(trial_quota)
+
+        if dify_config.HOSTED_XAI_PAID_ENABLED:
+            paid_models = self.parse_restrict_models_from_env("HOSTED_XAI_PAID_MODELS")
+            paid_quota = PaidHostingQuota(restrict_models=paid_models)
+            quotas.append(paid_quota)
+
+        if len(quotas) > 0:
+            credentials = {
+                "api_key": dify_config.HOSTED_XAI_API_KEY,
+            }
+
+            if dify_config.HOSTED_XAI_API_BASE:
+                credentials["endpoint_url"] = dify_config.HOSTED_XAI_API_BASE
+
+            return HostingProvider(enabled=True, credentials=credentials, quota_unit=quota_unit, quotas=quotas)
+
+        return HostingProvider(
+            enabled=False,
+            quota_unit=quota_unit,
+        )
+
+    def init_deepseek(self) -> HostingProvider:
+        quota_unit = QuotaUnit.CREDITS
+        quotas: list[HostingQuota] = []
+
+        if dify_config.HOSTED_DEEPSEEK_TRIAL_ENABLED:
+            hosted_quota_limit = 0
+            trail_models = self.parse_restrict_models_from_env("HOSTED_DEEPSEEK_TRIAL_MODELS")
+            trial_quota = TrialHostingQuota(quota_limit=hosted_quota_limit, restrict_models=trail_models)
+            quotas.append(trial_quota)
+
+        if dify_config.HOSTED_DEEPSEEK_PAID_ENABLED:
+            paid_models = self.parse_restrict_models_from_env("HOSTED_DEEPSEEK_PAID_MODELS")
+            paid_quota = PaidHostingQuota(restrict_models=paid_models)
+            quotas.append(paid_quota)
+
+        if len(quotas) > 0:
+            credentials = {
+                "api_key": dify_config.HOSTED_DEEPSEEK_API_KEY,
+            }
+
+            if dify_config.HOSTED_DEEPSEEK_API_BASE:
+                credentials["endpoint_url"] = dify_config.HOSTED_DEEPSEEK_API_BASE
+
+            return HostingProvider(enabled=True, credentials=credentials, quota_unit=quota_unit, quotas=quotas)
+
+        return HostingProvider(
+            enabled=False,
+            quota_unit=quota_unit,
+        )
+
     @staticmethod
     def init_minimax() -> HostingProvider:
         quota_unit = QuotaUnit.TOKENS

api/core/provider_manager.py

@@ -618,18 +618,18 @@ class ProviderManager:
                 )
 
             for quota in configuration.quotas:
-                if quota.quota_type == ProviderQuotaType.TRIAL:
+                if quota.quota_type in (ProviderQuotaType.TRIAL, ProviderQuotaType.PAID):
                     # Init trial provider records if not exists
-                    if ProviderQuotaType.TRIAL not in provider_quota_to_provider_record_dict:
+                    if quota.quota_type not in provider_quota_to_provider_record_dict:
                         try:
                             # FIXME ignore the type error, only TrialHostingQuota has limit need to change the logic
                             new_provider_record = Provider(
                                 tenant_id=tenant_id,
                                 # TODO: Use provider name with prefix after the data migration.
                                 provider_name=ModelProviderID(provider_name).provider_name,
-                                provider_type=ProviderType.SYSTEM,
-                                quota_type=ProviderQuotaType.TRIAL,
-                                quota_limit=quota.quota_limit,  # type: ignore
+                                provider_type=ProviderType.SYSTEM.value,
+                                quota_type=quota.quota_type,
+                                quota_limit=0,  # type: ignore
                                 quota_used=0,
                                 is_valid=True,
                             )
@@ -641,8 +641,8 @@ class ProviderManager:
                             stmt = select(Provider).where(
                                 Provider.tenant_id == tenant_id,
                                 Provider.provider_name == ModelProviderID(provider_name).provider_name,
-                                Provider.provider_type == ProviderType.SYSTEM,
-                                Provider.quota_type == ProviderQuotaType.TRIAL,
+                                Provider.provider_type == ProviderType.SYSTEM.value,
+                                Provider.quota_type == quota.quota_type,
                             )
                             existed_provider_record = db.session.scalar(stmt)
                             if not existed_provider_record:
@@ -912,6 +912,22 @@ class ProviderManager:
                 provider_record
             )
         quota_configurations = []
+
+        if dify_config.EDITION == "CLOUD":
+            from services.credit_pool_service import CreditPoolService
+
+            trail_pool = CreditPoolService.get_pool(
+                tenant_id=tenant_id,
+                pool_type=ProviderQuotaType.TRIAL.value,
+            )
+            paid_pool = CreditPoolService.get_pool(
+                tenant_id=tenant_id,
+                pool_type=ProviderQuotaType.PAID.value,
+            )
+        else:
+            trail_pool = None
+            paid_pool = None
+
         for provider_quota in provider_hosting_configuration.quotas:
             if provider_quota.quota_type not in quota_type_to_provider_records_dict:
                 if provider_quota.quota_type == ProviderQuotaType.FREE:
@@ -932,16 +948,36 @@ class ProviderManager:
                     raise ValueError("quota_used is None")
                 if provider_record.quota_limit is None:
                     raise ValueError("quota_limit is None")
+                if provider_quota.quota_type == ProviderQuotaType.TRIAL and trail_pool is not None:
+                    quota_configuration = QuotaConfiguration(
+                        quota_type=provider_quota.quota_type,
+                        quota_unit=provider_hosting_configuration.quota_unit or QuotaUnit.TOKENS,
+                        quota_used=trail_pool.quota_used,
+                        quota_limit=trail_pool.quota_limit,
+                        is_valid=trail_pool.quota_limit > trail_pool.quota_used or trail_pool.quota_limit == -1,
+                        restrict_models=provider_quota.restrict_models,
+                    )
 
-                quota_configuration = QuotaConfiguration(
-                    quota_type=provider_quota.quota_type,
-                    quota_unit=provider_hosting_configuration.quota_unit or QuotaUnit.TOKENS,
-                    quota_used=provider_record.quota_used,
-                    quota_limit=provider_record.quota_limit,
-                    is_valid=provider_record.quota_limit > provider_record.quota_used
-                    or provider_record.quota_limit == -1,
-                    restrict_models=provider_quota.restrict_models,
-                )
+                elif provider_quota.quota_type == ProviderQuotaType.PAID and paid_pool is not None:
+                    quota_configuration = QuotaConfiguration(
+                        quota_type=provider_quota.quota_type,
+                        quota_unit=provider_hosting_configuration.quota_unit or QuotaUnit.TOKENS,
+                        quota_used=paid_pool.quota_used,
+                        quota_limit=paid_pool.quota_limit,
+                        is_valid=paid_pool.quota_limit > paid_pool.quota_used or paid_pool.quota_limit == -1,
+                        restrict_models=provider_quota.restrict_models,
+                    )
+
+                else:
+                    quota_configuration = QuotaConfiguration(
+                        quota_type=provider_quota.quota_type,
+                        quota_unit=provider_hosting_configuration.quota_unit or QuotaUnit.TOKENS,
+                        quota_used=provider_record.quota_used,
+                        quota_limit=provider_record.quota_limit,
+                        is_valid=provider_record.quota_limit > provider_record.quota_used
+                        or provider_record.quota_limit == -1,
+                        restrict_models=provider_quota.restrict_models,
+                    )
 
             quota_configurations.append(quota_configuration)
 

api/core/repositories/sqlalchemy_workflow_node_execution_repository.py

@@ -29,7 +29,6 @@ from models import (
     Account,
     CreatorUserRole,
     EndUser,
-    LLMGenerationDetail,
     WorkflowNodeExecutionModel,
     WorkflowNodeExecutionTriggeredFrom,
 )
@@ -458,113 +457,6 @@ class SQLAlchemyWorkflowNodeExecutionRepository(WorkflowNodeExecutionRepository)
             session.merge(db_model)
             session.flush()
 
-            # Save LLMGenerationDetail for LLM nodes with successful execution
-            if (
-                domain_model.node_type == NodeType.LLM
-                and domain_model.status == WorkflowNodeExecutionStatus.SUCCEEDED
-                and domain_model.outputs is not None
-            ):
-                self._save_llm_generation_detail(session, domain_model)
-
-    def _save_llm_generation_detail(self, session, execution: WorkflowNodeExecution) -> None:
-        """
-        Save LLM generation detail for LLM nodes.
-        Extracts reasoning_content, tool_calls, and sequence from outputs and metadata.
-        """
-        outputs = execution.outputs or {}
-        metadata = execution.metadata or {}
-
-        reasoning_list = self._extract_reasoning(outputs)
-        tool_calls_list = self._extract_tool_calls(metadata.get(WorkflowNodeExecutionMetadataKey.AGENT_LOG))
-
-        if not reasoning_list and not tool_calls_list:
-            return
-
-        sequence = self._build_generation_sequence(outputs.get("text", ""), reasoning_list, tool_calls_list)
-        self._upsert_generation_detail(session, execution, reasoning_list, tool_calls_list, sequence)
-
-    def _extract_reasoning(self, outputs: Mapping[str, Any]) -> list[str]:
-        """Extract reasoning_content as a clean list of non-empty strings."""
-        reasoning_content = outputs.get("reasoning_content")
-        if isinstance(reasoning_content, str):
-            trimmed = reasoning_content.strip()
-            return [trimmed] if trimmed else []
-        if isinstance(reasoning_content, list):
-            return [item.strip() for item in reasoning_content if isinstance(item, str) and item.strip()]
-        return []
-
-    def _extract_tool_calls(self, agent_log: Any) -> list[dict[str, str]]:
-        """Extract tool call records from agent logs."""
-        if not agent_log or not isinstance(agent_log, list):
-            return []
-
-        tool_calls: list[dict[str, str]] = []
-        for log in agent_log:
-            log_data = log.data if hasattr(log, "data") else (log.get("data", {}) if isinstance(log, dict) else {})
-            tool_name = log_data.get("tool_name")
-            if tool_name and str(tool_name).strip():
-                tool_calls.append(
-                    {
-                        "id": log_data.get("tool_call_id", ""),
-                        "name": tool_name,
-                        "arguments": json.dumps(log_data.get("tool_args", {})),
-                        "result": str(log_data.get("output", "")),
-                    }
-                )
-        return tool_calls
-
-    def _build_generation_sequence(
-        self, text: str, reasoning_list: list[str], tool_calls_list: list[dict[str, str]]
-    ) -> list[dict[str, Any]]:
-        """Build a simple content/reasoning/tool_call sequence."""
-        sequence: list[dict[str, Any]] = []
-        if text:
-            sequence.append({"type": "content", "start": 0, "end": len(text)})
-        for index in range(len(reasoning_list)):
-            sequence.append({"type": "reasoning", "index": index})
-        for index in range(len(tool_calls_list)):
-            sequence.append({"type": "tool_call", "index": index})
-        return sequence
-
-    def _upsert_generation_detail(
-        self,
-        session,
-        execution: WorkflowNodeExecution,
-        reasoning_list: list[str],
-        tool_calls_list: list[dict[str, str]],
-        sequence: list[dict[str, Any]],
-    ) -> None:
-        """Insert or update LLMGenerationDetail with serialized fields."""
-        existing = (
-            session.query(LLMGenerationDetail)
-            .filter_by(
-                workflow_run_id=execution.workflow_execution_id,
-                node_id=execution.node_id,
-            )
-            .first()
-        )
-
-        reasoning_json = json.dumps(reasoning_list) if reasoning_list else None
-        tool_calls_json = json.dumps(tool_calls_list) if tool_calls_list else None
-        sequence_json = json.dumps(sequence) if sequence else None
-
-        if existing:
-            existing.reasoning_content = reasoning_json
-            existing.tool_calls = tool_calls_json
-            existing.sequence = sequence_json
-            return
-
-        generation_detail = LLMGenerationDetail(
-            tenant_id=self._tenant_id,
-            app_id=self._app_id,
-            workflow_run_id=execution.workflow_execution_id,
-            node_id=execution.node_id,
-            reasoning_content=reasoning_json,
-            tool_calls=tool_calls_json,
-            sequence=sequence_json,
-        )
-        session.add(generation_detail)
-
     def get_db_models_by_workflow_run(
         self,
         workflow_run_id: str,

api/core/tools/__base/tool.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from models.model import File
 
-from core.model_runtime.entities.message_entities import PromptMessageTool
 from core.tools.__base.tool_runtime import ToolRuntime
 from core.tools.entities.tool_entities import (
     ToolEntity,
@@ -155,60 +154,6 @@ class Tool(ABC):
 
         return parameters
 
-    def to_prompt_message_tool(self) -> PromptMessageTool:
-        message_tool = PromptMessageTool(
-            name=self.entity.identity.name,
-            description=self.entity.description.llm if self.entity.description else "",
-            parameters={
-                "type": "object",
-                "properties": {},
-                "required": [],
-            },
-        )
-
-        parameters = self.get_merged_runtime_parameters()
-        for parameter in parameters:
-            if parameter.form != ToolParameter.ToolParameterForm.LLM:
-                continue
-
-            parameter_type = parameter.type.as_normal_type()
-            if parameter.type in {
-                ToolParameter.ToolParameterType.SYSTEM_FILES,
-                ToolParameter.ToolParameterType.FILE,
-                ToolParameter.ToolParameterType.FILES,
-            }:
-                # Determine the description based on parameter type
-                if parameter.type == ToolParameter.ToolParameterType.FILE:
-                    file_format_desc = " Input the file id with format: [File: file_id]."
-                else:
-                    file_format_desc = "Input the file id with format: [Files: file_id1, file_id2, ...]. "
-
-                message_tool.parameters["properties"][parameter.name] = {
-                    "type": "string",
-                    "description": (parameter.llm_description or "") + file_format_desc,
-                }
-                continue
-            enum = []
-            if parameter.type == ToolParameter.ToolParameterType.SELECT:
-                enum = [option.value for option in parameter.options] if parameter.options else []
-
-            message_tool.parameters["properties"][parameter.name] = (
-                {
-                    "type": parameter_type,
-                    "description": parameter.llm_description or "",
-                }
-                if parameter.input_schema is None
-                else parameter.input_schema
-            )
-
-            if len(enum) > 0:
-                message_tool.parameters["properties"][parameter.name]["enum"] = enum
-
-            if parameter.required:
-                message_tool.parameters["required"].append(parameter.name)
-
-        return message_tool
-
     def create_image_message(
         self,
         image: str,

api/core/workflow/entities/__init__.py

@@ -1,16 +1,11 @@
 from .agent import AgentNodeStrategyInit
 from .graph_init_params import GraphInitParams
-from .tool_entities import ToolCall, ToolCallResult, ToolResult, ToolResultStatus
 from .workflow_execution import WorkflowExecution
 from .workflow_node_execution import WorkflowNodeExecution
 
 __all__ = [
     "AgentNodeStrategyInit",
     "GraphInitParams",
-    "ToolCall",
-    "ToolCallResult",
-    "ToolResult",
-    "ToolResultStatus",
     "WorkflowExecution",
     "WorkflowNodeExecution",
 ]

api/core/workflow/entities/tool_entities.py

@@ -1,39 +0,0 @@
-from enum import StrEnum
-
-from pydantic import BaseModel, Field
-
-from core.file import File
-
-
-class ToolResultStatus(StrEnum):
-    SUCCESS = "success"
-    ERROR = "error"
-
-
-class ToolCall(BaseModel):
-    id: str | None = Field(default=None, description="Unique identifier for this tool call")
-    name: str | None = Field(default=None, description="Name of the tool being called")
-    arguments: str | None = Field(default=None, description="Accumulated tool arguments JSON")
-    icon: str | dict | None = Field(default=None, description="Icon of the tool")
-    icon_dark: str | dict | None = Field(default=None, description="Dark theme icon of the tool")
-
-
-class ToolResult(BaseModel):
-    id: str | None = Field(default=None, description="Identifier of the tool call this result belongs to")
-    name: str | None = Field(default=None, description="Name of the tool")
-    output: str | None = Field(default=None, description="Tool output text, error or success message")
-    files: list[str] = Field(default_factory=list, description="File produced by tool")
-    status: ToolResultStatus | None = Field(default=ToolResultStatus.SUCCESS, description="Tool execution status")
-    elapsed_time: float | None = Field(default=None, description="Elapsed seconds spent executing the tool")
-    icon: str | dict | None = Field(default=None, description="Icon of the tool")
-    icon_dark: str | dict | None = Field(default=None, description="Dark theme icon of the tool")
-
-
-class ToolCallResult(BaseModel):
-    id: str | None = Field(default=None, description="Identifier for the tool call")
-    name: str | None = Field(default=None, description="Name of the tool")
-    arguments: str | None = Field(default=None, description="Accumulated tool arguments JSON")
-    output: str | None = Field(default=None, description="Tool output text, error or success message")
-    files: list[File] = Field(default_factory=list, description="File produced by tool")
-    status: ToolResultStatus = Field(default=ToolResultStatus.SUCCESS, description="Tool execution status")
-    elapsed_time: float | None = Field(default=None, description="Elapsed seconds spent executing the tool")

api/core/workflow/enums.py

@@ -247,8 +247,6 @@ class WorkflowNodeExecutionMetadataKey(StrEnum):
     ERROR_STRATEGY = "error_strategy"  # node in continue on error mode return the field
     LOOP_VARIABLE_MAP = "loop_variable_map"  # single loop variable output
     DATASOURCE_INFO = "datasource_info"
-    LLM_CONTENT_SEQUENCE = "llm_content_sequence"
-    LLM_TRACE = "llm_trace"
     COMPLETED_REASON = "completed_reason"  # completed reason for loop node
 
 

api/core/workflow/graph_engine/response_coordinator/coordinator.py

@@ -16,13 +16,7 @@ from pydantic import BaseModel, Field
 
 from core.workflow.enums import NodeExecutionType, NodeState
 from core.workflow.graph import Graph
-from core.workflow.graph_events import (
-    ChunkType,
-    NodeRunStreamChunkEvent,
-    NodeRunSucceededEvent,
-    ToolCall,
-    ToolResult,
-)
+from core.workflow.graph_events import NodeRunStreamChunkEvent, NodeRunSucceededEvent
 from core.workflow.nodes.base.template import TextSegment, VariableSegment
 from core.workflow.runtime import VariablePool
 
@@ -327,24 +321,11 @@ class ResponseStreamCoordinator:
         selector: Sequence[str],
         chunk: str,
         is_final: bool = False,
-        chunk_type: ChunkType = ChunkType.TEXT,
-        tool_call: ToolCall | None = None,
-        tool_result: ToolResult | None = None,
     ) -> NodeRunStreamChunkEvent:
         """Create a stream chunk event with consistent structure.
 
         For selectors with special prefixes (sys, env, conversation), we use the
         active response node's information since these are not actual node IDs.
-
-        Args:
-            node_id: The node ID to attribute the event to
-            execution_id: The execution ID for this node
-            selector: The variable selector
-            chunk: The chunk content
-            is_final: Whether this is the final chunk
-            chunk_type: The semantic type of the chunk being streamed
-            tool_call: Structured data for tool_call chunks
-            tool_result: Structured data for tool_result chunks
         """
         # Check if this is a special selector that doesn't correspond to a node
         if selector and selector[0] not in self._graph.nodes and self._active_session:
@@ -357,9 +338,6 @@ class ResponseStreamCoordinator:
                 selector=selector,
                 chunk=chunk,
                 is_final=is_final,
-                chunk_type=chunk_type,
-                tool_call=tool_call,
-                tool_result=tool_result,
             )
 
         # Standard case: selector refers to an actual node
@@ -371,9 +349,6 @@ class ResponseStreamCoordinator:
             selector=selector,
             chunk=chunk,
             is_final=is_final,
-            chunk_type=chunk_type,
-            tool_call=tool_call,
-            tool_result=tool_result,
         )
 
     def _process_variable_segment(self, segment: VariableSegment) -> tuple[Sequence[NodeRunStreamChunkEvent], bool]:
@@ -381,8 +356,6 @@ class ResponseStreamCoordinator:
 
         Handles both regular node selectors and special system selectors (sys, env, conversation).
         For special selectors, we attribute the output to the active response node.
-
-        For object-type variables, automatically streams all child fields that have stream events.
         """
         events: list[NodeRunStreamChunkEvent] = []
         source_selector_prefix = segment.selector[0] if segment.selector else ""
@@ -391,81 +364,60 @@ class ResponseStreamCoordinator:
         # Determine which node to attribute the output to
         # For special selectors (sys, env, conversation), use the active response node
         # For regular selectors, use the source node
-        active_session = self._active_session
-        special_selector = bool(active_session and source_selector_prefix not in self._graph.nodes)
-        output_node_id = active_session.node_id if special_selector and active_session else source_selector_prefix
+        if self._active_session and source_selector_prefix not in self._graph.nodes:
+            # Special selector - use active response node
+            output_node_id = self._active_session.node_id
+        else:
+            # Regular node selector
+            output_node_id = source_selector_prefix
         execution_id = self._get_or_create_execution_id(output_node_id)
 
-        # Check if there's a direct stream for this selector
-        has_direct_stream = (
-            tuple(segment.selector) in self._stream_buffers or tuple(segment.selector) in self._closed_streams
-        )
-
-        stream_targets = [segment.selector] if has_direct_stream else sorted(self._find_child_streams(segment.selector))
-
-        if stream_targets:
-            all_complete = True
-
-            for target_selector in stream_targets:
-                while self._has_unread_stream(target_selector):
-                    if event := self._pop_stream_chunk(target_selector):
-                        events.append(
-                            self._rewrite_stream_event(
-                                event=event,
-                                output_node_id=output_node_id,
-                                execution_id=execution_id,
-                                special_selector=bool(special_selector),
-                            )
-                        )
-
-                if not self._is_stream_closed(target_selector):
-                    all_complete = False
-
-            is_complete = all_complete
-
-        # Fallback: check if scalar value exists in variable pool
-        if not is_complete and not has_direct_stream:
-            if value := self._variable_pool.get(segment.selector):
-                # Process scalar value
-                is_last_segment = bool(
-                    self._active_session
-                    and self._active_session.index == len(self._active_session.template.segments) - 1
-                )
-                events.append(
-                    self._create_stream_chunk_event(
-                        node_id=output_node_id,
-                        execution_id=execution_id,
-                        selector=segment.selector,
-                        chunk=value.markdown,
-                        is_final=is_last_segment,
+        # Stream all available chunks
+        while self._has_unread_stream(segment.selector):
+            if event := self._pop_stream_chunk(segment.selector):
+                # For special selectors, we need to update the event to use
+                # the active response node's information
+                if self._active_session and source_selector_prefix not in self._graph.nodes:
+                    response_node = self._graph.nodes[self._active_session.node_id]
+                    # Create a new event with the response node's information
+                    # but keep the original selector
+                    updated_event = NodeRunStreamChunkEvent(
+                        id=execution_id,
+                        node_id=response_node.id,
+                        node_type=response_node.node_type,
+                        selector=event.selector,  # Keep original selector
+                        chunk=event.chunk,
+                        is_final=event.is_final,
                     )
+                    events.append(updated_event)
+                else:
+                    # Regular node selector - use event as is
+                    events.append(event)
+
+        # Check if this is the last chunk by looking ahead
+        stream_closed = self._is_stream_closed(segment.selector)
+        # Check if stream is closed to determine if segment is complete
+        if stream_closed:
+            is_complete = True
+
+        elif value := self._variable_pool.get(segment.selector):
+            # Process scalar value
+            is_last_segment = bool(
+                self._active_session and self._active_session.index == len(self._active_session.template.segments) - 1
+            )
+            events.append(
+                self._create_stream_chunk_event(
+                    node_id=output_node_id,
+                    execution_id=execution_id,
+                    selector=segment.selector,
+                    chunk=value.markdown,
+                    is_final=is_last_segment,
                 )
-                is_complete = True
+            )
+            is_complete = True
 
         return events, is_complete
 
-    def _rewrite_stream_event(
-        self,
-        event: NodeRunStreamChunkEvent,
-        output_node_id: str,
-        execution_id: str,
-        special_selector: bool,
-    ) -> NodeRunStreamChunkEvent:
-        """Rewrite event to attribute to active response node when selector is special."""
-        if not special_selector:
-            return event
-
-        return self._create_stream_chunk_event(
-            node_id=output_node_id,
-            execution_id=execution_id,
-            selector=event.selector,
-            chunk=event.chunk,
-            is_final=event.is_final,
-            chunk_type=event.chunk_type,
-            tool_call=event.tool_call,
-            tool_result=event.tool_result,
-        )
-
     def _process_text_segment(self, segment: TextSegment) -> Sequence[NodeRunStreamChunkEvent]:
         """Process a text segment. Returns (events, is_complete)."""
         assert self._active_session is not None
@@ -561,36 +513,6 @@ class ResponseStreamCoordinator:
 
     # ============= Internal Stream Management Methods =============
 
-    def _find_child_streams(self, parent_selector: Sequence[str]) -> list[tuple[str, ...]]:
-        """Find all child stream selectors that are descendants of the parent selector.
-
-        For example, if parent_selector is ['llm', 'generation'], this will find:
-        - ['llm', 'generation', 'content']
-        - ['llm', 'generation', 'tool_calls']
-        - ['llm', 'generation', 'tool_results']
-        - ['llm', 'generation', 'thought']
-
-        Args:
-            parent_selector: The parent selector to search for children
-
-        Returns:
-            List of child selector tuples found in stream buffers or closed streams
-        """
-        parent_key = tuple(parent_selector)
-        parent_len = len(parent_key)
-        child_streams: set[tuple[str, ...]] = set()
-
-        # Search in both active buffers and closed streams
-        all_selectors = set(self._stream_buffers.keys()) | self._closed_streams
-
-        for selector_key in all_selectors:
-            # Check if this selector is a direct child of the parent
-            # Direct child means: len(child) == len(parent) + 1 and child starts with parent
-            if len(selector_key) == parent_len + 1 and selector_key[:parent_len] == parent_key:
-                child_streams.add(selector_key)
-
-        return sorted(child_streams)
-
     def _append_stream_chunk(self, selector: Sequence[str], event: NodeRunStreamChunkEvent) -> None:
         """
         Append a stream chunk to the internal buffer.

api/core/workflow/graph_events/__init__.py

@@ -36,7 +36,6 @@ from .loop import (
 
 # Node events
 from .node import (
-    ChunkType,
     NodeRunExceptionEvent,
     NodeRunFailedEvent,
     NodeRunPauseRequestedEvent,
@@ -45,13 +44,10 @@ from .node import (
     NodeRunStartedEvent,
     NodeRunStreamChunkEvent,
     NodeRunSucceededEvent,
-    ToolCall,
-    ToolResult,
 )
 
 __all__ = [
     "BaseGraphEvent",
-    "ChunkType",
     "GraphEngineEvent",
     "GraphNodeEventBase",
     "GraphRunAbortedEvent",
@@ -77,6 +73,4 @@ __all__ = [
     "NodeRunStartedEvent",
     "NodeRunStreamChunkEvent",
     "NodeRunSucceededEvent",
-    "ToolCall",
-    "ToolResult",
 ]

api/core/workflow/graph_events/node.py

@@ -1,11 +1,10 @@
 from collections.abc import Sequence
 from datetime import datetime
-from enum import StrEnum
 
 from pydantic import Field
 
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
-from core.workflow.entities import AgentNodeStrategyInit, ToolCall, ToolResult
+from core.workflow.entities import AgentNodeStrategyInit
 from core.workflow.entities.pause_reason import PauseReason
 
 from .base import GraphNodeEventBase
@@ -22,39 +21,13 @@ class NodeRunStartedEvent(GraphNodeEventBase):
     provider_id: str = ""
 
 
-class ChunkType(StrEnum):
-    """Stream chunk type for LLM-related events."""
-
-    TEXT = "text"  # Normal text streaming
-    TOOL_CALL = "tool_call"  # Tool call arguments streaming
-    TOOL_RESULT = "tool_result"  # Tool execution result
-    THOUGHT = "thought"  # Agent thinking process (ReAct)
-    THOUGHT_START = "thought_start"  # Agent thought start
-    THOUGHT_END = "thought_end"  # Agent thought end
-
-
 class NodeRunStreamChunkEvent(GraphNodeEventBase):
-    """Stream chunk event for workflow node execution."""
-
-    # Base fields
+    # Spec-compliant fields
     selector: Sequence[str] = Field(
         ..., description="selector identifying the output location (e.g., ['nodeA', 'text'])"
     )
     chunk: str = Field(..., description="the actual chunk content")
     is_final: bool = Field(default=False, description="indicates if this is the last chunk")
-    chunk_type: ChunkType = Field(default=ChunkType.TEXT, description="type of the chunk")
-
-    # Tool call fields (when chunk_type == TOOL_CALL)
-    tool_call: ToolCall | None = Field(
-        default=None,
-        description="structured payload for tool_call chunks",
-    )
-
-    # Tool result fields (when chunk_type == TOOL_RESULT)
-    tool_result: ToolResult | None = Field(
-        default=None,
-        description="structured payload for tool_result chunks",
-    )
 
 
 class NodeRunRetrieverResourceEvent(GraphNodeEventBase):

api/core/workflow/node_events/__init__.py

@@ -13,21 +13,16 @@ from .loop import (
     LoopSucceededEvent,
 )
 from .node import (
-    ChunkType,
     ModelInvokeCompletedEvent,
     PauseRequestedEvent,
     RunRetrieverResourceEvent,
     RunRetryEvent,
     StreamChunkEvent,
     StreamCompletedEvent,
-    ThoughtChunkEvent,
-    ToolCallChunkEvent,
-    ToolResultChunkEvent,
 )
 
 __all__ = [
     "AgentLogEvent",
-    "ChunkType",
     "IterationFailedEvent",
     "IterationNextEvent",
     "IterationStartedEvent",
@@ -44,7 +39,4 @@ __all__ = [
     "RunRetryEvent",
     "StreamChunkEvent",
     "StreamCompletedEvent",
-    "ThoughtChunkEvent",
-    "ToolCallChunkEvent",
-    "ToolResultChunkEvent",
 ]

api/core/workflow/node_events/node.py

@@ -1,13 +1,11 @@
 from collections.abc import Sequence
 from datetime import datetime
-from enum import StrEnum
 
 from pydantic import Field
 
 from core.file import File
 from core.model_runtime.entities.llm_entities import LLMUsage
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
-from core.workflow.entities import ToolCall, ToolResult
 from core.workflow.entities.pause_reason import PauseReason
 from core.workflow.node_events import NodeRunResult
 
@@ -34,60 +32,13 @@ class RunRetryEvent(NodeEventBase):
     start_at: datetime = Field(..., description="Retry start time")
 
 
-class ChunkType(StrEnum):
-    """Stream chunk type for LLM-related events."""
-
-    TEXT = "text"  # Normal text streaming
-    TOOL_CALL = "tool_call"  # Tool call arguments streaming
-    TOOL_RESULT = "tool_result"  # Tool execution result
-    THOUGHT = "thought"  # Agent thinking process (ReAct)
-    THOUGHT_START = "thought_start"  # Agent thought start
-    THOUGHT_END = "thought_end"  # Agent thought end
-
-
 class StreamChunkEvent(NodeEventBase):
-    """Base stream chunk event - normal text streaming output."""
-
+    # Spec-compliant fields
     selector: Sequence[str] = Field(
         ..., description="selector identifying the output location (e.g., ['nodeA', 'text'])"
     )
     chunk: str = Field(..., description="the actual chunk content")
     is_final: bool = Field(default=False, description="indicates if this is the last chunk")
-    chunk_type: ChunkType = Field(default=ChunkType.TEXT, description="type of the chunk")
-    tool_call: ToolCall | None = Field(default=None, description="structured payload for tool_call chunks")
-    tool_result: ToolResult | None = Field(default=None, description="structured payload for tool_result chunks")
-
-
-class ToolCallChunkEvent(StreamChunkEvent):
-    """Tool call streaming event - tool call arguments streaming output."""
-
-    chunk_type: ChunkType = Field(default=ChunkType.TOOL_CALL, frozen=True)
-    tool_call: ToolCall | None = Field(default=None, description="structured tool call payload")
-
-
-class ToolResultChunkEvent(StreamChunkEvent):
-    """Tool result event - tool execution result."""
-
-    chunk_type: ChunkType = Field(default=ChunkType.TOOL_RESULT, frozen=True)
-    tool_result: ToolResult | None = Field(default=None, description="structured tool result payload")
-
-
-class ThoughtStartChunkEvent(StreamChunkEvent):
-    """Agent thought start streaming event - Agent thinking process (ReAct)."""
-
-    chunk_type: ChunkType = Field(default=ChunkType.THOUGHT_START, frozen=True)
-
-
-class ThoughtEndChunkEvent(StreamChunkEvent):
-    """Agent thought end streaming event - Agent thinking process (ReAct)."""
-
-    chunk_type: ChunkType = Field(default=ChunkType.THOUGHT_END, frozen=True)
-
-
-class ThoughtChunkEvent(StreamChunkEvent):
-    """Agent thought streaming event - Agent thinking process (ReAct)."""
-
-    chunk_type: ChunkType = Field(default=ChunkType.THOUGHT, frozen=True)
 
 
 class StreamCompletedEvent(NodeEventBase):

api/core/workflow/nodes/base/node.py

@@ -48,9 +48,6 @@ from core.workflow.node_events import (
     RunRetrieverResourceEvent,
     StreamChunkEvent,
     StreamCompletedEvent,
-    ThoughtChunkEvent,
-    ToolCallChunkEvent,
-    ToolResultChunkEvent,
 )
 from core.workflow.runtime import GraphRuntimeState
 from libs.datetime_utils import naive_utc_now
@@ -567,8 +564,6 @@ class Node(Generic[NodeDataT]):
 
     @_dispatch.register
     def _(self, event: StreamChunkEvent) -> NodeRunStreamChunkEvent:
-        from core.workflow.graph_events import ChunkType
-
         return NodeRunStreamChunkEvent(
             id=self.execution_id,
             node_id=self._node_id,
@@ -576,60 +571,6 @@ class Node(Generic[NodeDataT]):
             selector=event.selector,
             chunk=event.chunk,
             is_final=event.is_final,
-            chunk_type=ChunkType(event.chunk_type.value),
-            tool_call=event.tool_call,
-            tool_result=event.tool_result,
-        )
-
-    @_dispatch.register
-    def _(self, event: ToolCallChunkEvent) -> NodeRunStreamChunkEvent:
-        from core.workflow.graph_events import ChunkType
-
-        return NodeRunStreamChunkEvent(
-            id=self._node_execution_id,
-            node_id=self._node_id,
-            node_type=self.node_type,
-            selector=event.selector,
-            chunk=event.chunk,
-            is_final=event.is_final,
-            chunk_type=ChunkType.TOOL_CALL,
-            tool_call=event.tool_call,
-        )
-
-    @_dispatch.register
-    def _(self, event: ToolResultChunkEvent) -> NodeRunStreamChunkEvent:
-        from core.workflow.entities import ToolResult, ToolResultStatus
-        from core.workflow.graph_events import ChunkType
-
-        tool_result = event.tool_result or ToolResult()
-        status: ToolResultStatus = tool_result.status or ToolResultStatus.SUCCESS
-        tool_result = tool_result.model_copy(
-            update={"status": status, "files": tool_result.files or []},
-        )
-
-        return NodeRunStreamChunkEvent(
-            id=self._node_execution_id,
-            node_id=self._node_id,
-            node_type=self.node_type,
-            selector=event.selector,
-            chunk=event.chunk,
-            is_final=event.is_final,
-            chunk_type=ChunkType.TOOL_RESULT,
-            tool_result=tool_result,
-        )
-
-    @_dispatch.register
-    def _(self, event: ThoughtChunkEvent) -> NodeRunStreamChunkEvent:
-        from core.workflow.graph_events import ChunkType
-
-        return NodeRunStreamChunkEvent(
-            id=self._node_execution_id,
-            node_id=self._node_id,
-            node_type=self.node_type,
-            selector=event.selector,
-            chunk=event.chunk,
-            is_final=event.is_final,
-            chunk_type=ChunkType.THOUGHT,
         )
 
     @_dispatch.register

api/core/workflow/nodes/llm/__init__.py

@@ -3,7 +3,6 @@ from .entities import (
     LLMNodeCompletionModelPromptTemplate,
     LLMNodeData,
     ModelConfig,
-    ToolMetadata,
     VisionConfig,
 )
 from .node import LLMNode
@@ -14,6 +13,5 @@ __all__ = [
     "LLMNodeCompletionModelPromptTemplate",
     "LLMNodeData",
     "ModelConfig",
-    "ToolMetadata",
     "VisionConfig",
 ]

api/core/workflow/nodes/llm/entities.py

@@ -1,17 +1,10 @@
-import re
 from collections.abc import Mapping, Sequence
 from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, Field, field_validator
 
-from core.agent.entities import AgentLog, AgentResult
-from core.file import File
 from core.model_runtime.entities import ImagePromptMessageContent, LLMMode
-from core.model_runtime.entities.llm_entities import LLMUsage
 from core.prompt.entities.advanced_prompt_entities import ChatModelMessage, CompletionModelPromptTemplate, MemoryConfig
-from core.tools.entities.tool_entities import ToolProviderType
-from core.workflow.entities import ToolCall, ToolCallResult
-from core.workflow.node_events import AgentLogEvent
 from core.workflow.nodes.base import BaseNodeData
 from core.workflow.nodes.base.entities import VariableSelector
 
@@ -65,268 +58,6 @@ class LLMNodeCompletionModelPromptTemplate(CompletionModelPromptTemplate):
     jinja2_text: str | None = None
 
 
-class ToolMetadata(BaseModel):
-    """
-    Tool metadata for LLM node with tool support.
-
-    Defines the essential fields needed for tool configuration,
-    particularly the 'type' field to identify tool provider type.
-    """
-
-    # Core fields
-    enabled: bool = True
-    type: ToolProviderType = Field(..., description="Tool provider type: builtin, api, mcp, workflow")
-    provider_name: str = Field(..., description="Tool provider name/identifier")
-    tool_name: str = Field(..., description="Tool name")
-
-    # Optional fields
-    plugin_unique_identifier: str | None = Field(None, description="Plugin unique identifier for plugin tools")
-    credential_id: str | None = Field(None, description="Credential ID for tools requiring authentication")
-
-    # Configuration fields
-    parameters: dict[str, Any] = Field(default_factory=dict, description="Tool parameters")
-    settings: dict[str, Any] = Field(default_factory=dict, description="Tool settings configuration")
-    extra: dict[str, Any] = Field(default_factory=dict, description="Extra tool configuration like custom description")
-
-
-class ModelTraceSegment(BaseModel):
-    """Model invocation trace segment with token usage and output."""
-
-    text: str | None = Field(None, description="Model output text content")
-    reasoning: str | None = Field(None, description="Reasoning/thought content from model")
-    tool_calls: list[ToolCall] = Field(default_factory=list, description="Tool calls made by the model")
-
-
-class ToolTraceSegment(BaseModel):
-    """Tool invocation trace segment with call details and result."""
-
-    id: str | None = Field(default=None, description="Unique identifier for this tool call")
-    name: str | None = Field(default=None, description="Name of the tool being called")
-    arguments: str | None = Field(default=None, description="Accumulated tool arguments JSON")
-    output: str | None = Field(default=None, description="Tool call result")
-
-
-class LLMTraceSegment(BaseModel):
-    """
-    Streaming trace segment for LLM tool-enabled runs.
-
-    Represents alternating model and tool invocations in sequence:
-    model -> tool -> model -> tool -> ...
-
-    Each segment records its execution duration.
-    """
-
-    type: Literal["model", "tool"]
-    duration: float = Field(..., description="Execution duration in seconds")
-    usage: LLMUsage | None = Field(default=None, description="Token usage statistics for this model call")
-    output: ModelTraceSegment | ToolTraceSegment = Field(..., description="Output of the segment")
-
-    # Common metadata for both model and tool segments
-    provider: str | None = Field(default=None, description="Model or tool provider identifier")
-    name: str | None = Field(default=None, description="Name of the model or tool")
-    icon: str | None = Field(default=None, description="Icon for the provider")
-    icon_dark: str | None = Field(default=None, description="Dark theme icon for the provider")
-    error: str | None = Field(default=None, description="Error message if segment failed")
-    status: Literal["success", "error"] | None = Field(default=None, description="Tool execution status")
-
-
-class LLMGenerationData(BaseModel):
-    """Generation data from LLM invocation with tools.
-
-    For multi-turn tool calls like: thought1 -> text1 -> tool_call1 -> thought2 -> text2 -> tool_call2
-    - reasoning_contents: [thought1, thought2, ...] - one element per turn
-    - tool_calls: [{id, name, arguments, result}, ...] - all tool calls with results
-    """
-
-    text: str = Field(..., description="Accumulated text content from all turns")
-    reasoning_contents: list[str] = Field(default_factory=list, description="Reasoning content per turn")
-    tool_calls: list[ToolCallResult] = Field(default_factory=list, description="Tool calls with results")
-    sequence: list[dict[str, Any]] = Field(default_factory=list, description="Ordered segments for rendering")
-    usage: LLMUsage = Field(..., description="LLM usage statistics")
-    finish_reason: str | None = Field(None, description="Finish reason from LLM")
-    files: list[File] = Field(default_factory=list, description="Generated files")
-    trace: list[LLMTraceSegment] = Field(default_factory=list, description="Streaming trace in emitted order")
-
-
-class ThinkTagStreamParser:
-    """Lightweight state machine to split streaming chunks by <think> tags."""
-
-    _START_PATTERN = re.compile(r"<think(?:\s[^>]*)?>", re.IGNORECASE)
-    _END_PATTERN = re.compile(r"</think>", re.IGNORECASE)
-    _START_PREFIX = "<think"
-    _END_PREFIX = "</think"
-
-    def __init__(self):
-        self._buffer = ""
-        self._in_think = False
-
-    @staticmethod
-    def _suffix_prefix_len(text: str, prefix: str) -> int:
-        """Return length of the longest suffix of `text` that is a prefix of `prefix`."""
-        max_len = min(len(text), len(prefix) - 1)
-        for i in range(max_len, 0, -1):
-            if text[-i:].lower() == prefix[:i].lower():
-                return i
-        return 0
-
-    def process(self, chunk: str) -> list[tuple[str, str]]:
-        """
-        Split incoming chunk into ('thought' | 'text', content) tuples.
-        Content excludes the <think> tags themselves and handles split tags across chunks.
-        """
-        parts: list[tuple[str, str]] = []
-        self._buffer += chunk
-
-        while self._buffer:
-            if self._in_think:
-                end_match = self._END_PATTERN.search(self._buffer)
-                if end_match:
-                    thought_text = self._buffer[: end_match.start()]
-                    if thought_text:
-                        parts.append(("thought", thought_text))
-                    parts.append(("thought_end", ""))
-                    self._buffer = self._buffer[end_match.end() :]
-                    self._in_think = False
-                    continue
-
-                hold_len = self._suffix_prefix_len(self._buffer, self._END_PREFIX)
-                emit = self._buffer[: len(self._buffer) - hold_len]
-                if emit:
-                    parts.append(("thought", emit))
-                self._buffer = self._buffer[-hold_len:] if hold_len > 0 else ""
-                break
-
-            start_match = self._START_PATTERN.search(self._buffer)
-            if start_match:
-                prefix = self._buffer[: start_match.start()]
-                if prefix:
-                    parts.append(("text", prefix))
-                self._buffer = self._buffer[start_match.end() :]
-                parts.append(("thought_start", ""))
-                self._in_think = True
-                continue
-
-            hold_len = self._suffix_prefix_len(self._buffer, self._START_PREFIX)
-            emit = self._buffer[: len(self._buffer) - hold_len]
-            if emit:
-                parts.append(("text", emit))
-            self._buffer = self._buffer[-hold_len:] if hold_len > 0 else ""
-            break
-
-        cleaned_parts: list[tuple[str, str]] = []
-        for kind, content in parts:
-            # Extra safeguard: strip any stray tags that slipped through.
-            content = self._START_PATTERN.sub("", content)
-            content = self._END_PATTERN.sub("", content)
-            if content or kind in {"thought_start", "thought_end"}:
-                cleaned_parts.append((kind, content))
-
-        return cleaned_parts
-
-    def flush(self) -> list[tuple[str, str]]:
-        """Flush remaining buffer when the stream ends."""
-        if not self._buffer:
-            return []
-        kind = "thought" if self._in_think else "text"
-        content = self._buffer
-        # Drop dangling partial tags instead of emitting them
-        if content.lower().startswith(self._START_PREFIX) or content.lower().startswith(self._END_PREFIX):
-            content = ""
-        self._buffer = ""
-        if not content and not self._in_think:
-            return []
-        # Strip any complete tags that might still be present.
-        content = self._START_PATTERN.sub("", content)
-        content = self._END_PATTERN.sub("", content)
-
-        result: list[tuple[str, str]] = []
-        if content:
-            result.append((kind, content))
-        if self._in_think:
-            result.append(("thought_end", ""))
-            self._in_think = False
-        return result
-
-
-class StreamBuffers(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    think_parser: ThinkTagStreamParser = Field(default_factory=ThinkTagStreamParser)
-    pending_thought: list[str] = Field(default_factory=list)
-    pending_content: list[str] = Field(default_factory=list)
-    pending_tool_calls: list[ToolCall] = Field(default_factory=list)
-    current_turn_reasoning: list[str] = Field(default_factory=list)
-    reasoning_per_turn: list[str] = Field(default_factory=list)
-
-
-class TraceState(BaseModel):
-    trace_segments: list[LLMTraceSegment] = Field(default_factory=list)
-    tool_trace_map: dict[str, LLMTraceSegment] = Field(default_factory=dict)
-    tool_call_index_map: dict[str, int] = Field(default_factory=dict)
-    model_segment_start_time: float | None = Field(default=None, description="Start time for current model segment")
-    pending_usage: LLMUsage | None = Field(default=None, description="Pending usage for current model segment")
-
-
-class AggregatedResult(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    text: str = ""
-    files: list[File] = Field(default_factory=list)
-    usage: LLMUsage = Field(default_factory=LLMUsage.empty_usage)
-    finish_reason: str | None = None
-
-
-class AgentContext(BaseModel):
-    agent_logs: list[AgentLogEvent] = Field(default_factory=list)
-    agent_result: AgentResult | None = None
-
-
-class ToolOutputState(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    stream: StreamBuffers = Field(default_factory=StreamBuffers)
-    trace: TraceState = Field(default_factory=TraceState)
-    aggregate: AggregatedResult = Field(default_factory=AggregatedResult)
-    agent: AgentContext = Field(default_factory=AgentContext)
-
-
-class ToolLogPayload(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    tool_name: str = ""
-    tool_call_id: str = ""
-    tool_args: dict[str, Any] = Field(default_factory=dict)
-    tool_output: Any = None
-    tool_error: Any = None
-    files: list[Any] = Field(default_factory=list)
-    meta: dict[str, Any] = Field(default_factory=dict)
-
-    @classmethod
-    def from_log(cls, log: AgentLog) -> "ToolLogPayload":
-        data = log.data or {}
-        return cls(
-            tool_name=data.get("tool_name", ""),
-            tool_call_id=data.get("tool_call_id", ""),
-            tool_args=data.get("tool_args") or {},
-            tool_output=data.get("output"),
-            tool_error=data.get("error"),
-            files=data.get("files") or [],
-            meta=data.get("meta") or {},
-        )
-
-    @classmethod
-    def from_mapping(cls, data: Mapping[str, Any]) -> "ToolLogPayload":
-        return cls(
-            tool_name=data.get("tool_name", ""),
-            tool_call_id=data.get("tool_call_id", ""),
-            tool_args=data.get("tool_args") or {},
-            tool_output=data.get("output"),
-            tool_error=data.get("error"),
-            files=data.get("files") or [],
-            meta=data.get("meta") or {},
-        )
-
-
 class LLMNodeData(BaseNodeData):
     model: ModelConfig
     prompt_template: Sequence[LLMNodeChatModelMessage] | LLMNodeCompletionModelPromptTemplate
@@ -355,10 +86,6 @@ class LLMNodeData(BaseNodeData):
         ),
     )
 
-    # Tool support
-    tools: Sequence[ToolMetadata] = Field(default_factory=list)
-    max_iterations: int | None = Field(default=None, description="Maximum number of iterations for the LLM node")
-
     @field_validator("prompt_config", mode="before")
     @classmethod
     def convert_none_prompt_config(cls, v: Any):

api/core/workflow/nodes/llm/llm_utils.py

@@ -6,7 +6,7 @@ from sqlalchemy.orm import Session
 
 from configs import dify_config
 from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
-from core.entities.provider_entities import QuotaUnit
+from core.entities.provider_entities import ProviderQuotaType, QuotaUnit
 from core.file.models import File
 from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance, ModelManager
@@ -136,21 +136,37 @@ def deduct_llm_quota(tenant_id: str, model_instance: ModelInstance, usage: LLMUs
             used_quota = 1
 
     if used_quota is not None and system_configuration.current_quota_type is not None:
-        with Session(db.engine) as session:
-            stmt = (
-                update(Provider)
-                .where(
-                    Provider.tenant_id == tenant_id,
-                    # TODO: Use provider name with prefix after the data migration.
-                    Provider.provider_name == ModelProviderID(model_instance.provider).provider_name,
-                    Provider.provider_type == ProviderType.SYSTEM,
-                    Provider.quota_type == system_configuration.current_quota_type.value,
-                    Provider.quota_limit > Provider.quota_used,
-                )
-                .values(
-                    quota_used=Provider.quota_used + used_quota,
-                    last_used=naive_utc_now(),
-                )
+        if system_configuration.current_quota_type == ProviderQuotaType.TRIAL:
+            from services.credit_pool_service import CreditPoolService
+
+            CreditPoolService.check_and_deduct_credits(
+                tenant_id=tenant_id,
+                credits_required=used_quota,
             )
-            session.execute(stmt)
-            session.commit()
+        elif system_configuration.current_quota_type == ProviderQuotaType.PAID:
+            from services.credit_pool_service import CreditPoolService
+
+            CreditPoolService.check_and_deduct_credits(
+                tenant_id=tenant_id,
+                credits_required=used_quota,
+                pool_type="paid",
+            )
+        else:
+            with Session(db.engine) as session:
+                stmt = (
+                    update(Provider)
+                    .where(
+                        Provider.tenant_id == tenant_id,
+                        # TODO: Use provider name with prefix after the data migration.
+                        Provider.provider_name == ModelProviderID(model_instance.provider).provider_name,
+                        Provider.provider_type == ProviderType.SYSTEM.value,
+                        Provider.quota_type == system_configuration.current_quota_type.value,
+                        Provider.quota_limit > Provider.quota_used,
+                    )
+                    .values(
+                        quota_used=Provider.quota_used + used_quota,
+                        last_used=naive_utc_now(),
+                    )
+                )
+                session.execute(stmt)
+                session.commit()

api/events/event_handlers/update_provider_when_message_created.py

@@ -10,7 +10,7 @@ from sqlalchemy.orm import Session
 
 from configs import dify_config
 from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity, ChatAppGenerateEntity
-from core.entities.provider_entities import QuotaUnit, SystemConfiguration
+from core.entities.provider_entities import ProviderQuotaType, QuotaUnit, SystemConfiguration
 from events.message_event import message_was_created
 from extensions.ext_database import db
 from extensions.ext_redis import redis_client, redis_fallback
@@ -134,22 +134,38 @@ def handle(sender: Message, **kwargs):
             system_configuration=system_configuration,
             model_name=model_config.model,
         )
-
         if used_quota is not None:
-            quota_update = _ProviderUpdateOperation(
-                filters=_ProviderUpdateFilters(
+            if provider_configuration.system_configuration.current_quota_type == ProviderQuotaType.TRIAL:
+                from services.credit_pool_service import CreditPoolService
+
+                CreditPoolService.check_and_deduct_credits(
                     tenant_id=tenant_id,
-                    provider_name=ModelProviderID(model_config.provider).provider_name,
-                    provider_type=ProviderType.SYSTEM,
-                    quota_type=provider_configuration.system_configuration.current_quota_type.value,
-                ),
-                values=_ProviderUpdateValues(quota_used=Provider.quota_used + used_quota, last_used=current_time),
-                additional_filters=_ProviderUpdateAdditionalFilters(
-                    quota_limit_check=True  # Provider.quota_limit > Provider.quota_used
-                ),
-                description="quota_deduction_update",
-            )
-            updates_to_perform.append(quota_update)
+                    credits_required=used_quota,
+                    pool_type="trial",
+                )
+            elif provider_configuration.system_configuration.current_quota_type == ProviderQuotaType.PAID:
+                from services.credit_pool_service import CreditPoolService
+
+                CreditPoolService.check_and_deduct_credits(
+                    tenant_id=tenant_id,
+                    credits_required=used_quota,
+                    pool_type="paid",
+                )
+            else:
+                quota_update = _ProviderUpdateOperation(
+                    filters=_ProviderUpdateFilters(
+                        tenant_id=tenant_id,
+                        provider_name=ModelProviderID(model_config.provider).provider_name,
+                        provider_type=ProviderType.SYSTEM.value,
+                        quota_type=provider_configuration.system_configuration.current_quota_type.value,
+                    ),
+                    values=_ProviderUpdateValues(quota_used=Provider.quota_used + used_quota, last_used=current_time),
+                    additional_filters=_ProviderUpdateAdditionalFilters(
+                        quota_limit_check=True  # Provider.quota_limit > Provider.quota_used
+                    ),
+                    description="quota_deduction_update",
+                )
+                updates_to_perform.append(quota_update)
 
     # Execute all updates
     start_time = time_module.perf_counter()

api/fields/conversation_fields.py

@@ -169,7 +169,6 @@ class MessageDetail(ResponseModel):
     status: str
     error: str | None = None
     parent_message_id: str | None = None
-    generation_detail: JSONValue | None = Field(default=None, validation_alias="generation_detail_dict")
 
     @field_validator("inputs", mode="before")
     @classmethod

api/fields/message_fields.py

@@ -59,7 +59,6 @@ class MessageListItem(ResponseModel):
     message_files: list[MessageFile]
     status: str
     error: str | None = None
-    generation_detail: JSONValueType | None = Field(default=None, validation_alias="generation_detail_dict")
 
     @field_validator("inputs", mode="before")
     @classmethod

api/fields/workflow_run_fields.py

@@ -81,7 +81,6 @@ workflow_run_detail_fields = {
     "inputs": fields.Raw(attribute="inputs_dict"),
     "status": fields.String,
     "outputs": fields.Raw(attribute="outputs_dict"),
-    "outputs_as_generation": fields.Boolean,
     "error": fields.String,
     "elapsed_time": fields.Float,
     "total_tokens": fields.Integer,
@@ -130,7 +129,6 @@ workflow_run_node_execution_fields = {
     "inputs_truncated": fields.Boolean,
     "outputs_truncated": fields.Boolean,
     "process_data_truncated": fields.Boolean,
-    "generation_detail": fields.Raw,
 }
 
 workflow_run_node_execution_list_fields = {

api/migrations/versions/2025_12_17_1617-85c8b4a64f53_add_llm_generation_detail_table.py

@@ -1,46 +0,0 @@
-"""add llm generation detail table.
-
-Revision ID: 85c8b4a64f53
-Revises: 7bb281b7a422
-Create Date: 2025-12-10 16:17:46.597669
-
-"""
-from alembic import op
-import models as models
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision = '85c8b4a64f53'
-down_revision = '03ea244985ce'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('llm_generation_details',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
-    sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
-    sa.Column('app_id', models.types.StringUUID(), nullable=False),
-    sa.Column('message_id', models.types.StringUUID(), nullable=True),
-    sa.Column('workflow_run_id', models.types.StringUUID(), nullable=True),
-    sa.Column('node_id', sa.String(length=255), nullable=True),
-    sa.Column('reasoning_content', models.types.LongText(), nullable=True),
-    sa.Column('tool_calls', models.types.LongText(), nullable=True),
-    sa.Column('sequence', models.types.LongText(), nullable=True),
-    sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
-    sa.CheckConstraint('(message_id IS NOT NULL AND workflow_run_id IS NULL AND node_id IS NULL) OR (message_id IS NULL AND workflow_run_id IS NOT NULL AND node_id IS NOT NULL)', name=op.f('llm_generation_details_ck_llm_generation_detail_assoc_mode_check')),
-    sa.PrimaryKeyConstraint('id', name='llm_generation_detail_pkey'),
-    sa.UniqueConstraint('message_id', name=op.f('llm_generation_details_message_id_key'))
-    )
-    with op.batch_alter_table('llm_generation_details', schema=None) as batch_op:
-        batch_op.create_index('idx_llm_generation_detail_message', ['message_id'], unique=False)
-        batch_op.create_index('idx_llm_generation_detail_workflow', ['workflow_run_id', 'node_id'], unique=False)
-
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('llm_generation_details')
-    # ### end Alembic commands ###

api/migrations/versions/2025_12_25_1039-7df29de0f6be_add_credit_pool.py

@@ -0,0 +1,46 @@
+"""add credit pool
+
+Revision ID: 7df29de0f6be
+Revises: 03ea244985ce
+Create Date: 2025-12-25 10:39:15.139304
+
+"""
+from alembic import op
+import models as models
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '7df29de0f6be'
+down_revision = '03ea244985ce'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('tenant_credit_pools',
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
+    sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
+    sa.Column('pool_type', sa.String(length=40), server_default='trial', nullable=False),
+    sa.Column('quota_limit', sa.BigInteger(), nullable=False),
+    sa.Column('quota_used', sa.BigInteger(), nullable=False),
+    sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
+    sa.Column('updated_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
+    sa.PrimaryKeyConstraint('id', name='tenant_credit_pool_pkey')
+    )
+    with op.batch_alter_table('tenant_credit_pools', schema=None) as batch_op:
+        batch_op.create_index('tenant_credit_pool_pool_type_idx', ['pool_type'], unique=False)
+        batch_op.create_index('tenant_credit_pool_tenant_id_idx', ['tenant_id'], unique=False)
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+   
+    with op.batch_alter_table('tenant_credit_pools', schema=None) as batch_op:
+        batch_op.drop_index('tenant_credit_pool_tenant_id_idx')
+        batch_op.drop_index('tenant_credit_pool_pool_type_idx')
+
+    op.drop_table('tenant_credit_pools')
+    # ### end Alembic commands ###

api/models/__init__.py

@@ -49,7 +49,6 @@ from .model import (
     EndUser,
     IconType,
     InstalledApp,
-    LLMGenerationDetail,
     Message,
     MessageAgentThought,
     MessageAnnotation,
@@ -61,6 +60,7 @@ from .model import (
     Site,
     Tag,
     TagBinding,
+    TenantCreditPool,
     TraceAppConfig,
     UploadFile,
 )
@@ -155,7 +155,6 @@ __all__ = [
     "IconType",
     "InstalledApp",
     "InvitationCode",
-    "LLMGenerationDetail",
     "LoadBalancingModelConfig",
     "Message",
     "MessageAgentThought",
@@ -179,6 +178,7 @@ __all__ = [
     "Tenant",
     "TenantAccountJoin",
     "TenantAccountRole",
+    "TenantCreditPool",
     "TenantDefaultModel",
     "TenantPreferredModelProvider",
     "TenantStatus",

api/models/model.py

@@ -12,8 +12,8 @@ from uuid import uuid4
 
 import sqlalchemy as sa
 from flask import request
-from flask_login import UserMixin
-from sqlalchemy import Float, Index, PrimaryKeyConstraint, String, exists, func, select, text
+from flask_login import UserMixin  # type: ignore[import-untyped]
+from sqlalchemy import BigInteger, Float, Index, PrimaryKeyConstraint, String, exists, func, select, text
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
 from configs import dify_config
@@ -33,8 +33,6 @@ from .provider_ids import GenericProviderID
 from .types import LongText, StringUUID
 
 if TYPE_CHECKING:
-    from core.app.entities.llm_generation_entities import LLMGenerationDetailData
-
     from .workflow import Workflow
 
 
@@ -1206,18 +1204,6 @@ class Message(Base):
             .all()
         )
 
-    # FIXME (Novice) -- It's easy to cause N+1 query problem here.
-    @property
-    def generation_detail(self) -> dict[str, Any] | None:
-        """
-        Get LLM generation detail for this message.
-        Returns the detail as a dictionary or None if not found.
-        """
-        detail = db.session.query(LLMGenerationDetail).filter_by(message_id=self.id).first()
-        if detail:
-            return detail.to_dict()
-        return None
-
     @property
     def retriever_resources(self) -> Any:
         return self.message_metadata_dict.get("retriever_resources") if self.message_metadata else []
@@ -2089,85 +2075,27 @@ class TraceAppConfig(TypeBase):
         }
 
 
-class LLMGenerationDetail(Base):
-    """
-    Store LLM generation details including reasoning process and tool calls.
-
-    Association (choose one):
-    - For apps with Message: use message_id (one-to-one)
-    - For Workflow: use workflow_run_id + node_id (one run may have multiple LLM nodes)
-    """
-
-    __tablename__ = "llm_generation_details"
+class TenantCreditPool(Base):
+    __tablename__ = "tenant_credit_pools"
     __table_args__ = (
-        sa.PrimaryKeyConstraint("id", name="llm_generation_detail_pkey"),
-        sa.Index("idx_llm_generation_detail_message", "message_id"),
-        sa.Index("idx_llm_generation_detail_workflow", "workflow_run_id", "node_id"),
-        sa.CheckConstraint(
-            "(message_id IS NOT NULL AND workflow_run_id IS NULL AND node_id IS NULL)"
-            " OR "
-            "(message_id IS NULL AND workflow_run_id IS NOT NULL AND node_id IS NOT NULL)",
-            name="ck_llm_generation_detail_assoc_mode",
-        ),
+        sa.PrimaryKeyConstraint("id", name="tenant_credit_pool_pkey"),
+        sa.Index("tenant_credit_pool_tenant_id_idx", "tenant_id"),
+        sa.Index("tenant_credit_pool_pool_type_idx", "pool_type"),
     )
 
-    id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
-    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    id = mapped_column(StringUUID, primary_key=True, server_default=text("uuid_generate_v4()"))
+    tenant_id = mapped_column(StringUUID, nullable=False)
+    pool_type = mapped_column(String(40), nullable=False, default="trial", server_default="trial")
+    quota_limit = mapped_column(BigInteger, nullable=False, default=0)
+    quota_used = mapped_column(BigInteger, nullable=False, default=0)
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=text("CURRENT_TIMESTAMP"))
+    updated_at = mapped_column(
+        sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+    )
 
-    # Association fields (choose one)
-    message_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True, unique=True)
-    workflow_run_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
-    node_id: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    @property
+    def remaining_credits(self) -> int:
+        return max(0, self.quota_limit - self.quota_used)
 
-    # Core data as JSON strings
-    reasoning_content: Mapped[str | None] = mapped_column(LongText)
-    tool_calls: Mapped[str | None] = mapped_column(LongText)
-    sequence: Mapped[str | None] = mapped_column(LongText)
-
-    created_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
-
-    def to_domain_model(self) -> LLMGenerationDetailData:
-        """Convert to Pydantic domain model with proper validation."""
-        from core.app.entities.llm_generation_entities import LLMGenerationDetailData
-
-        return LLMGenerationDetailData(
-            reasoning_content=json.loads(self.reasoning_content) if self.reasoning_content else [],
-            tool_calls=json.loads(self.tool_calls) if self.tool_calls else [],
-            sequence=json.loads(self.sequence) if self.sequence else [],
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for API response."""
-        return self.to_domain_model().to_response_dict()
-
-    @classmethod
-    def from_domain_model(
-        cls,
-        data: LLMGenerationDetailData,
-        *,
-        tenant_id: str,
-        app_id: str,
-        message_id: str | None = None,
-        workflow_run_id: str | None = None,
-        node_id: str | None = None,
-    ) -> LLMGenerationDetail:
-        """Create from Pydantic domain model."""
-        # Enforce association mode at object creation time as well.
-        message_mode = message_id is not None
-        workflow_mode = workflow_run_id is not None or node_id is not None
-        if message_mode and workflow_mode:
-            raise ValueError("LLMGenerationDetail cannot set both message_id and workflow_run_id/node_id.")
-        if not message_mode and not (workflow_run_id and node_id):
-            raise ValueError("LLMGenerationDetail requires either message_id or workflow_run_id+node_id.")
-
-        return cls(
-            tenant_id=tenant_id,
-            app_id=app_id,
-            message_id=message_id,
-            workflow_run_id=workflow_run_id,
-            node_id=node_id,
-            reasoning_content=json.dumps(data.reasoning_content) if data.reasoning_content else None,
-            tool_calls=json.dumps([tc.model_dump() for tc in data.tool_calls]) if data.tool_calls else None,
-            sequence=json.dumps([seg.model_dump() for seg in data.sequence]) if data.sequence else None,
-        )
+    def has_sufficient_credits(self, required_credits: int) -> bool:
+        return self.remaining_credits >= required_credits

api/models/workflow.py

@@ -59,37 +59,6 @@ from .types import EnumText, LongText, StringUUID
 logger = logging.getLogger(__name__)
 
 
-def is_generation_outputs(outputs: Mapping[str, Any]) -> bool:
-    if not outputs:
-        return False
-
-    allowed_sequence_types = {"reasoning", "content", "tool_call"}
-
-    def valid_sequence_item(item: Mapping[str, Any]) -> bool:
-        return isinstance(item, Mapping) and item.get("type") in allowed_sequence_types
-
-    def valid_value(value: Any) -> bool:
-        if not isinstance(value, Mapping):
-            return False
-
-        content = value.get("content")
-        reasoning_content = value.get("reasoning_content")
-        tool_calls = value.get("tool_calls")
-        sequence = value.get("sequence")
-
-        return (
-            isinstance(content, str)
-            and isinstance(reasoning_content, list)
-            and all(isinstance(item, str) for item in reasoning_content)
-            and isinstance(tool_calls, list)
-            and all(isinstance(item, Mapping) for item in tool_calls)
-            and isinstance(sequence, list)
-            and all(valid_sequence_item(item) for item in sequence)
-        )
-
-    return all(valid_value(value) for value in outputs.values())
-
-
 class WorkflowType(StrEnum):
     """
     Workflow Type Enum
@@ -697,10 +666,6 @@ class WorkflowRun(Base):
     def workflow(self):
         return db.session.query(Workflow).where(Workflow.id == self.workflow_id).first()
 
-    @property
-    def outputs_as_generation(self):
-        return is_generation_outputs(self.outputs_dict)
-
     def to_dict(self):
         return {
             "id": self.id,
@@ -714,7 +679,6 @@ class WorkflowRun(Base):
             "inputs": self.inputs_dict,
             "status": self.status,
             "outputs": self.outputs_dict,
-            "outputs_as_generation": self.outputs_as_generation,
             "error": self.error,
             "elapsed_time": self.elapsed_time,
             "total_tokens": self.total_tokens,

api/services/account_service.py

@@ -999,6 +999,11 @@ class TenantService:
 
         tenant.encrypt_public_key = generate_key_pair(tenant.id)
         db.session.commit()
+
+        from services.credit_pool_service import CreditPoolService
+
+        CreditPoolService.create_default_pool(tenant.id)
+
         return tenant
 
     @staticmethod

api/services/credit_pool_service.py

@@ -0,0 +1,85 @@
+import logging
+
+from sqlalchemy import update
+from sqlalchemy.orm import Session
+
+from configs import dify_config
+from core.errors.error import QuotaExceededError
+from extensions.ext_database import db
+from models import TenantCreditPool
+
+logger = logging.getLogger(__name__)
+
+
+class CreditPoolService:
+    @classmethod
+    def create_default_pool(cls, tenant_id: str) -> TenantCreditPool:
+        """create default credit pool for new tenant"""
+        credit_pool = TenantCreditPool(
+            tenant_id=tenant_id, quota_limit=dify_config.HOSTED_POOL_CREDITS, quota_used=0, pool_type="trial"
+        )
+        db.session.add(credit_pool)
+        db.session.commit()
+        return credit_pool
+
+    @classmethod
+    def get_pool(cls, tenant_id: str, pool_type: str = "trial") -> TenantCreditPool | None:
+        """get tenant credit pool"""
+        return (
+            db.session.query(TenantCreditPool)
+            .filter_by(
+                tenant_id=tenant_id,
+                pool_type=pool_type,
+            )
+            .first()
+        )
+
+    @classmethod
+    def check_credits_available(
+        cls,
+        tenant_id: str,
+        credits_required: int,
+        pool_type: str = "trial",
+    ) -> bool:
+        """check if credits are available without deducting"""
+        pool = cls.get_pool(tenant_id, pool_type)
+        if not pool:
+            return False
+        return pool.remaining_credits >= credits_required
+
+    @classmethod
+    def check_and_deduct_credits(
+        cls,
+        tenant_id: str,
+        credits_required: int,
+        pool_type: str = "trial",
+    ) -> int:
+        """check and deduct credits, returns actual credits deducted"""
+
+        pool = cls.get_pool(tenant_id, pool_type)
+        if not pool:
+            raise QuotaExceededError("Credit pool not found")
+
+        if pool.remaining_credits <= 0:
+            raise QuotaExceededError("No credits remaining")
+
+        # deduct all remaining credits if less than required
+        actual_credits = min(credits_required, pool.remaining_credits)
+
+        try:
+            with Session(db.engine) as session:
+                stmt = (
+                    update(TenantCreditPool)
+                    .where(
+                        TenantCreditPool.tenant_id == tenant_id,
+                        TenantCreditPool.pool_type == pool_type,
+                    )
+                    .values(quota_used=TenantCreditPool.quota_used + actual_credits)
+                )
+                session.execute(stmt)
+                session.commit()
+        except Exception:
+            logger.exception("Failed to deduct credits for tenant %s", tenant_id)
+            raise QuotaExceededError("Failed to deduct credits")
+
+        return actual_credits

api/services/feature_service.py

@@ -140,6 +140,7 @@ class FeatureModel(BaseModel):
     # pydantic configs
     model_config = ConfigDict(protected_namespaces=())
     knowledge_pipeline: KnowledgePipeline = KnowledgePipeline()
+    next_credit_reset_date: int = 0
 
 
 class KnowledgeRateLimitModel(BaseModel):
@@ -301,6 +302,9 @@ class FeatureService:
         if "knowledge_pipeline_publish_enabled" in billing_info:
             features.knowledge_pipeline.publish_enabled = billing_info["knowledge_pipeline_publish_enabled"]
 
+        if "next_credit_reset_date" in billing_info:
+            features.next_credit_reset_date = billing_info["next_credit_reset_date"]
+
     @classmethod
     def _fulfill_params_from_enterprise(cls, features: SystemFeatureModel):
         enterprise_info = EnterpriseService.get_info()

api/services/llm_generation_service.py

@@ -1,37 +0,0 @@
-"""
-LLM Generation Detail Service.
-
-Provides methods to query and attach generation details to workflow node executions
-and messages, avoiding N+1 query problems.
-"""
-
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-from core.app.entities.llm_generation_entities import LLMGenerationDetailData
-from models import LLMGenerationDetail
-
-
-class LLMGenerationService:
-    """Service for handling LLM generation details."""
-
-    def __init__(self, session: Session):
-        self._session = session
-
-    def get_generation_detail_for_message(self, message_id: str) -> LLMGenerationDetailData | None:
-        """Query generation detail for a specific message."""
-        stmt = select(LLMGenerationDetail).where(LLMGenerationDetail.message_id == message_id)
-        detail = self._session.scalars(stmt).first()
-        return detail.to_domain_model() if detail else None
-
-    def get_generation_details_for_messages(
-        self,
-        message_ids: list[str],
-    ) -> dict[str, LLMGenerationDetailData]:
-        """Batch query generation details for multiple messages."""
-        if not message_ids:
-            return {}
-
-        stmt = select(LLMGenerationDetail).where(LLMGenerationDetail.message_id.in_(message_ids))
-        details = self._session.scalars(stmt).all()
-        return {detail.message_id: detail.to_domain_model() for detail in details if detail.message_id}

api/services/trigger/trigger_provider_service.py

@@ -799,7 +799,7 @@ class TriggerProviderService:
         user_id: str,
         provider_id: TriggerProviderID,
         subscription_id: str,
-        credentials: Mapping[str, Any],
+        credentials: dict[str, Any],
     ) -> dict[str, Any]:
         """
         Verify credentials for an existing subscription without updating it.

api/services/workspace_service.py

@@ -31,7 +31,8 @@ class WorkspaceService:
         assert tenant_account_join is not None, "TenantAccountJoin not found"
         tenant_info["role"] = tenant_account_join.role
 
-        can_replace_logo = FeatureService.get_features(tenant.id).can_replace_logo
+        feature = FeatureService.get_features(tenant.id)
+        can_replace_logo = feature.can_replace_logo
 
         if can_replace_logo and TenantService.has_roles(tenant, [TenantAccountRole.OWNER, TenantAccountRole.ADMIN]):
             base_url = dify_config.FILES_URL
@@ -46,5 +47,19 @@ class WorkspaceService:
                 "remove_webapp_brand": remove_webapp_brand,
                 "replace_webapp_logo": replace_webapp_logo,
             }
+        if dify_config.EDITION == "CLOUD":
+            tenant_info["next_credit_reset_date"] = feature.next_credit_reset_date
+
+            from services.credit_pool_service import CreditPoolService
+
+            paid_pool = CreditPoolService.get_pool(tenant_id=tenant.id, pool_type="paid")
+            if paid_pool:
+                tenant_info["trial_credits"] = paid_pool.quota_limit
+                tenant_info["trial_credits_used"] = paid_pool.quota_used
+            else:
+                trial_pool = CreditPoolService.get_pool(tenant_id=tenant.id, pool_type="trial")
+                if trial_pool:
+                    tenant_info["trial_credits"] = trial_pool.quota_limit
+                    tenant_info["trial_credits_used"] = trial_pool.quota_used
 
         return tenant_info

api/tests/unit_tests/core/agent/__init__.py

@@ -1,3 +0,0 @@
-"""
-Mark agent test modules as a package to avoid import name collisions.
-"""

api/tests/unit_tests/core/agent/patterns/test_base.py

@@ -1,324 +0,0 @@
-"""Tests for AgentPattern base class."""
-
-from decimal import Decimal
-from unittest.mock import MagicMock
-
-import pytest
-
-from core.agent.entities import AgentLog, ExecutionContext
-from core.agent.patterns.base import AgentPattern
-from core.model_runtime.entities.llm_entities import LLMUsage
-
-
-class ConcreteAgentPattern(AgentPattern):
-    """Concrete implementation of AgentPattern for testing."""
-
-    def run(self, prompt_messages, model_parameters, stop=[], stream=True):
-        """Minimal implementation for testing."""
-        yield from []
-
-
-@pytest.fixture
-def mock_model_instance():
-    """Create a mock model instance."""
-    model_instance = MagicMock()
-    model_instance.model = "test-model"
-    model_instance.provider = "test-provider"
-    return model_instance
-
-
-@pytest.fixture
-def mock_context():
-    """Create a mock execution context."""
-    return ExecutionContext(
-        user_id="test-user",
-        app_id="test-app",
-        conversation_id="test-conversation",
-        message_id="test-message",
-        tenant_id="test-tenant",
-    )
-
-
-@pytest.fixture
-def agent_pattern(mock_model_instance, mock_context):
-    """Create a concrete agent pattern for testing."""
-    return ConcreteAgentPattern(
-        model_instance=mock_model_instance,
-        tools=[],
-        context=mock_context,
-        max_iterations=10,
-    )
-
-
-class TestAccumulateUsage:
-    """Tests for _accumulate_usage method."""
-
-    def test_accumulate_usage_to_empty_dict(self, agent_pattern):
-        """Test accumulating usage to an empty dict creates a copy."""
-        total_usage: dict = {"usage": None}
-        delta_usage = LLMUsage(
-            prompt_tokens=100,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.1"),
-            completion_tokens=50,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.1"),
-            total_tokens=150,
-            total_price=Decimal("0.2"),
-            currency="USD",
-            latency=0.5,
-        )
-
-        agent_pattern._accumulate_usage(total_usage, delta_usage)
-
-        assert total_usage["usage"] is not None
-        assert total_usage["usage"].total_tokens == 150
-        assert total_usage["usage"].prompt_tokens == 100
-        assert total_usage["usage"].completion_tokens == 50
-        # Verify it's a copy, not a reference
-        assert total_usage["usage"] is not delta_usage
-
-    def test_accumulate_usage_adds_to_existing(self, agent_pattern):
-        """Test accumulating usage adds to existing values."""
-        initial_usage = LLMUsage(
-            prompt_tokens=100,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.1"),
-            completion_tokens=50,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.1"),
-            total_tokens=150,
-            total_price=Decimal("0.2"),
-            currency="USD",
-            latency=0.5,
-        )
-        total_usage: dict = {"usage": initial_usage}
-
-        delta_usage = LLMUsage(
-            prompt_tokens=200,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.2"),
-            completion_tokens=100,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.2"),
-            total_tokens=300,
-            total_price=Decimal("0.4"),
-            currency="USD",
-            latency=0.5,
-        )
-
-        agent_pattern._accumulate_usage(total_usage, delta_usage)
-
-        assert total_usage["usage"].total_tokens == 450  # 150 + 300
-        assert total_usage["usage"].prompt_tokens == 300  # 100 + 200
-        assert total_usage["usage"].completion_tokens == 150  # 50 + 100
-
-    def test_accumulate_usage_multiple_rounds(self, agent_pattern):
-        """Test accumulating usage across multiple rounds."""
-        total_usage: dict = {"usage": None}
-
-        # Round 1: 100 tokens
-        round1_usage = LLMUsage(
-            prompt_tokens=70,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.07"),
-            completion_tokens=30,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.06"),
-            total_tokens=100,
-            total_price=Decimal("0.13"),
-            currency="USD",
-            latency=0.3,
-        )
-        agent_pattern._accumulate_usage(total_usage, round1_usage)
-        assert total_usage["usage"].total_tokens == 100
-
-        # Round 2: 150 tokens
-        round2_usage = LLMUsage(
-            prompt_tokens=100,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.1"),
-            completion_tokens=50,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.1"),
-            total_tokens=150,
-            total_price=Decimal("0.2"),
-            currency="USD",
-            latency=0.4,
-        )
-        agent_pattern._accumulate_usage(total_usage, round2_usage)
-        assert total_usage["usage"].total_tokens == 250  # 100 + 150
-
-        # Round 3: 200 tokens
-        round3_usage = LLMUsage(
-            prompt_tokens=130,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.13"),
-            completion_tokens=70,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.14"),
-            total_tokens=200,
-            total_price=Decimal("0.27"),
-            currency="USD",
-            latency=0.5,
-        )
-        agent_pattern._accumulate_usage(total_usage, round3_usage)
-        assert total_usage["usage"].total_tokens == 450  # 100 + 150 + 200
-
-
-class TestCreateLog:
-    """Tests for _create_log method."""
-
-    def test_create_log_with_label_and_status(self, agent_pattern):
-        """Test creating a log with label and status."""
-        log = agent_pattern._create_log(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={"key": "value"},
-        )
-
-        assert log.label == "ROUND 1"
-        assert log.log_type == AgentLog.LogType.ROUND
-        assert log.status == AgentLog.LogStatus.START
-        assert log.data == {"key": "value"}
-        assert log.parent_id is None
-
-    def test_create_log_with_parent_id(self, agent_pattern):
-        """Test creating a log with parent_id."""
-        parent_log = agent_pattern._create_log(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={},
-        )
-
-        child_log = agent_pattern._create_log(
-            label="CALL tool",
-            log_type=AgentLog.LogType.TOOL_CALL,
-            status=AgentLog.LogStatus.START,
-            data={},
-            parent_id=parent_log.id,
-        )
-
-        assert child_log.parent_id == parent_log.id
-        assert child_log.log_type == AgentLog.LogType.TOOL_CALL
-
-
-class TestFinishLog:
-    """Tests for _finish_log method."""
-
-    def test_finish_log_updates_status(self, agent_pattern):
-        """Test that finish_log updates status to SUCCESS."""
-        log = agent_pattern._create_log(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={},
-        )
-
-        finished_log = agent_pattern._finish_log(log, data={"result": "done"})
-
-        assert finished_log.status == AgentLog.LogStatus.SUCCESS
-        assert finished_log.data == {"result": "done"}
-
-    def test_finish_log_adds_usage_metadata(self, agent_pattern):
-        """Test that finish_log adds usage to metadata."""
-        log = agent_pattern._create_log(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={},
-        )
-
-        usage = LLMUsage(
-            prompt_tokens=100,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.1"),
-            completion_tokens=50,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.1"),
-            total_tokens=150,
-            total_price=Decimal("0.2"),
-            currency="USD",
-            latency=0.5,
-        )
-
-        finished_log = agent_pattern._finish_log(log, usage=usage)
-
-        assert finished_log.metadata[AgentLog.LogMetadata.TOTAL_TOKENS] == 150
-        assert finished_log.metadata[AgentLog.LogMetadata.TOTAL_PRICE] == Decimal("0.2")
-        assert finished_log.metadata[AgentLog.LogMetadata.CURRENCY] == "USD"
-        assert finished_log.metadata[AgentLog.LogMetadata.LLM_USAGE] == usage
-
-
-class TestFindToolByName:
-    """Tests for _find_tool_by_name method."""
-
-    def test_find_existing_tool(self, mock_model_instance, mock_context):
-        """Test finding an existing tool by name."""
-        mock_tool = MagicMock()
-        mock_tool.entity.identity.name = "test_tool"
-
-        pattern = ConcreteAgentPattern(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        found_tool = pattern._find_tool_by_name("test_tool")
-        assert found_tool == mock_tool
-
-    def test_find_nonexistent_tool_returns_none(self, mock_model_instance, mock_context):
-        """Test that finding a nonexistent tool returns None."""
-        mock_tool = MagicMock()
-        mock_tool.entity.identity.name = "test_tool"
-
-        pattern = ConcreteAgentPattern(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        found_tool = pattern._find_tool_by_name("nonexistent_tool")
-        assert found_tool is None
-
-
-class TestMaxIterationsCapping:
-    """Tests for max_iterations capping."""
-
-    def test_max_iterations_capped_at_99(self, mock_model_instance, mock_context):
-        """Test that max_iterations is capped at 99."""
-        pattern = ConcreteAgentPattern(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-            max_iterations=150,
-        )
-
-        assert pattern.max_iterations == 99
-
-    def test_max_iterations_not_capped_when_under_99(self, mock_model_instance, mock_context):
-        """Test that max_iterations is not capped when under 99."""
-        pattern = ConcreteAgentPattern(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-            max_iterations=50,
-        )
-
-        assert pattern.max_iterations == 50

api/tests/unit_tests/core/agent/patterns/test_function_call.py

@@ -1,332 +0,0 @@
-"""Tests for FunctionCallStrategy."""
-
-from decimal import Decimal
-from unittest.mock import MagicMock
-
-import pytest
-
-from core.agent.entities import AgentLog, ExecutionContext
-from core.model_runtime.entities.llm_entities import LLMUsage
-from core.model_runtime.entities.message_entities import (
-    PromptMessageTool,
-    SystemPromptMessage,
-    UserPromptMessage,
-)
-
-
-@pytest.fixture
-def mock_model_instance():
-    """Create a mock model instance."""
-    model_instance = MagicMock()
-    model_instance.model = "test-model"
-    model_instance.provider = "test-provider"
-    return model_instance
-
-
-@pytest.fixture
-def mock_context():
-    """Create a mock execution context."""
-    return ExecutionContext(
-        user_id="test-user",
-        app_id="test-app",
-        conversation_id="test-conversation",
-        message_id="test-message",
-        tenant_id="test-tenant",
-    )
-
-
-@pytest.fixture
-def mock_tool():
-    """Create a mock tool."""
-    tool = MagicMock()
-    tool.entity.identity.name = "test_tool"
-    tool.to_prompt_message_tool.return_value = PromptMessageTool(
-        name="test_tool",
-        description="A test tool",
-        parameters={
-            "type": "object",
-            "properties": {"param1": {"type": "string", "description": "A parameter"}},
-            "required": ["param1"],
-        },
-    )
-    return tool
-
-
-class TestFunctionCallStrategyInit:
-    """Tests for FunctionCallStrategy initialization."""
-
-    def test_initialization(self, mock_model_instance, mock_context, mock_tool):
-        """Test basic initialization."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-            max_iterations=10,
-        )
-
-        assert strategy.model_instance == mock_model_instance
-        assert strategy.context == mock_context
-        assert strategy.max_iterations == 10
-        assert len(strategy.tools) == 1
-
-    def test_initialization_with_tool_invoke_hook(self, mock_model_instance, mock_context, mock_tool):
-        """Test initialization with tool_invoke_hook."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        mock_hook = MagicMock()
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-            tool_invoke_hook=mock_hook,
-        )
-
-        assert strategy.tool_invoke_hook == mock_hook
-
-
-class TestConvertToolsToPromptFormat:
-    """Tests for _convert_tools_to_prompt_format method."""
-
-    def test_convert_tools_returns_prompt_message_tools(self, mock_model_instance, mock_context, mock_tool):
-        """Test that _convert_tools_to_prompt_format returns PromptMessageTool list."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        tools = strategy._convert_tools_to_prompt_format()
-
-        assert len(tools) == 1
-        assert isinstance(tools[0], PromptMessageTool)
-        assert tools[0].name == "test_tool"
-
-    def test_convert_tools_empty_when_no_tools(self, mock_model_instance, mock_context):
-        """Test that _convert_tools_to_prompt_format returns empty list when no tools."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        tools = strategy._convert_tools_to_prompt_format()
-
-        assert tools == []
-
-
-class TestAgentLogGeneration:
-    """Tests for AgentLog generation during run."""
-
-    def test_round_log_structure(self, mock_model_instance, mock_context, mock_tool):
-        """Test that round logs have correct structure."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-            max_iterations=1,
-        )
-
-        # Create a round log
-        round_log = strategy._create_log(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={"inputs": {"query": "test"}},
-        )
-
-        assert round_log.label == "ROUND 1"
-        assert round_log.log_type == AgentLog.LogType.ROUND
-        assert round_log.status == AgentLog.LogStatus.START
-        assert "inputs" in round_log.data
-
-    def test_tool_call_log_structure(self, mock_model_instance, mock_context, mock_tool):
-        """Test that tool call logs have correct structure."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        # Create a parent round log
-        round_log = strategy._create_log(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={},
-        )
-
-        # Create a tool call log
-        tool_log = strategy._create_log(
-            label="CALL test_tool",
-            log_type=AgentLog.LogType.TOOL_CALL,
-            status=AgentLog.LogStatus.START,
-            data={"tool_name": "test_tool", "tool_args": {"param1": "value1"}},
-            parent_id=round_log.id,
-        )
-
-        assert tool_log.label == "CALL test_tool"
-        assert tool_log.log_type == AgentLog.LogType.TOOL_CALL
-        assert tool_log.parent_id == round_log.id
-        assert tool_log.data["tool_name"] == "test_tool"
-
-
-class TestToolInvocation:
-    """Tests for tool invocation."""
-
-    def test_invoke_tool_with_hook(self, mock_model_instance, mock_context, mock_tool):
-        """Test that tool invocation uses hook when provided."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-        from core.tools.entities.tool_entities import ToolInvokeMeta
-
-        mock_hook = MagicMock()
-        mock_meta = ToolInvokeMeta(
-            time_cost=0.5,
-            error=None,
-            tool_config={"tool_provider_type": "test", "tool_provider": "test_id"},
-        )
-        mock_hook.return_value = ("Tool result", ["file-1"], mock_meta)
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-            tool_invoke_hook=mock_hook,
-        )
-
-        result, files, meta = strategy._invoke_tool(mock_tool, {"param1": "value"}, "test_tool")
-
-        mock_hook.assert_called_once()
-        assert result == "Tool result"
-        assert files == []  # Hook returns file IDs, but _invoke_tool returns empty File list
-        assert meta == mock_meta
-
-    def test_invoke_tool_without_hook_attribute_set(self, mock_model_instance, mock_context, mock_tool):
-        """Test that tool_invoke_hook is None when not provided."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-            tool_invoke_hook=None,
-        )
-
-        # Verify that tool_invoke_hook is None
-        assert strategy.tool_invoke_hook is None
-
-
-class TestUsageTracking:
-    """Tests for usage tracking across rounds."""
-
-    def test_round_usage_is_separate_from_total(self, mock_model_instance, mock_context):
-        """Test that round usage is tracked separately from total."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        # Simulate two rounds of usage
-        total_usage: dict = {"usage": None}
-        round1_usage: dict = {"usage": None}
-        round2_usage: dict = {"usage": None}
-
-        # Round 1
-        usage1 = LLMUsage(
-            prompt_tokens=100,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.1"),
-            completion_tokens=50,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.1"),
-            total_tokens=150,
-            total_price=Decimal("0.2"),
-            currency="USD",
-            latency=0.5,
-        )
-        strategy._accumulate_usage(round1_usage, usage1)
-        strategy._accumulate_usage(total_usage, usage1)
-
-        # Round 2
-        usage2 = LLMUsage(
-            prompt_tokens=200,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.2"),
-            completion_tokens=100,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.2"),
-            total_tokens=300,
-            total_price=Decimal("0.4"),
-            currency="USD",
-            latency=0.5,
-        )
-        strategy._accumulate_usage(round2_usage, usage2)
-        strategy._accumulate_usage(total_usage, usage2)
-
-        # Verify round usage is separate
-        assert round1_usage["usage"].total_tokens == 150
-        assert round2_usage["usage"].total_tokens == 300
-        # Verify total is accumulated
-        assert total_usage["usage"].total_tokens == 450
-
-
-class TestPromptMessageHandling:
-    """Tests for prompt message handling."""
-
-    def test_messages_include_system_and_user(self, mock_model_instance, mock_context, mock_tool):
-        """Test that messages include system and user prompts."""
-        from core.agent.patterns.function_call import FunctionCallStrategy
-
-        strategy = FunctionCallStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        messages = [
-            SystemPromptMessage(content="You are a helpful assistant."),
-            UserPromptMessage(content="Hello"),
-        ]
-
-        # Just verify the messages can be processed
-        assert len(messages) == 2
-        assert isinstance(messages[0], SystemPromptMessage)
-        assert isinstance(messages[1], UserPromptMessage)
-
-    def test_assistant_message_with_tool_calls(self, mock_model_instance, mock_context, mock_tool):
-        """Test that assistant messages can contain tool calls."""
-        from core.model_runtime.entities.message_entities import AssistantPromptMessage
-
-        tool_call = AssistantPromptMessage.ToolCall(
-            id="call_123",
-            type="function",
-            function=AssistantPromptMessage.ToolCall.ToolCallFunction(
-                name="test_tool",
-                arguments='{"param1": "value1"}',
-            ),
-        )
-
-        assistant_message = AssistantPromptMessage(
-            content="I'll help you with that.",
-            tool_calls=[tool_call],
-        )
-
-        assert len(assistant_message.tool_calls) == 1
-        assert assistant_message.tool_calls[0].function.name == "test_tool"

api/tests/unit_tests/core/agent/patterns/test_react.py

@@ -1,224 +0,0 @@
-"""Tests for ReActStrategy."""
-
-from unittest.mock import MagicMock
-
-import pytest
-
-from core.agent.entities import ExecutionContext
-from core.agent.patterns.react import ReActStrategy
-from core.model_runtime.entities import SystemPromptMessage, UserPromptMessage
-
-
-@pytest.fixture
-def mock_model_instance():
-    """Create a mock model instance."""
-    model_instance = MagicMock()
-    model_instance.model = "test-model"
-    model_instance.provider = "test-provider"
-    return model_instance
-
-
-@pytest.fixture
-def mock_context():
-    """Create a mock execution context."""
-    return ExecutionContext(
-        user_id="test-user",
-        app_id="test-app",
-        conversation_id="test-conversation",
-        message_id="test-message",
-        tenant_id="test-tenant",
-    )
-
-
-@pytest.fixture
-def mock_tool():
-    """Create a mock tool."""
-    from core.model_runtime.entities.message_entities import PromptMessageTool
-
-    tool = MagicMock()
-    tool.entity.identity.name = "test_tool"
-    tool.entity.identity.provider = "test_provider"
-
-    # Use real PromptMessageTool for proper serialization
-    prompt_tool = PromptMessageTool(
-        name="test_tool",
-        description="A test tool",
-        parameters={"type": "object", "properties": {}},
-    )
-    tool.to_prompt_message_tool.return_value = prompt_tool
-
-    return tool
-
-
-class TestReActStrategyInit:
-    """Tests for ReActStrategy initialization."""
-
-    def test_init_with_instruction(self, mock_model_instance, mock_context):
-        """Test that instruction is stored correctly."""
-        instruction = "You are a helpful assistant."
-
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-            instruction=instruction,
-        )
-
-        assert strategy.instruction == instruction
-
-    def test_init_with_empty_instruction(self, mock_model_instance, mock_context):
-        """Test that empty instruction is handled correctly."""
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        assert strategy.instruction == ""
-
-
-class TestBuildPromptWithReactFormat:
-    """Tests for _build_prompt_with_react_format method."""
-
-    def test_replace_tools_placeholder(self, mock_model_instance, mock_context, mock_tool):
-        """Test that {{tools}} placeholder is replaced."""
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        system_content = "You have access to: {{tools}}"
-        messages = [
-            SystemPromptMessage(content=system_content),
-            UserPromptMessage(content="Hello"),
-        ]
-
-        result = strategy._build_prompt_with_react_format(messages, [], True)
-
-        # The tools placeholder should be replaced with JSON
-        assert "{{tools}}" not in result[0].content
-        assert "test_tool" in result[0].content
-
-    def test_replace_tool_names_placeholder(self, mock_model_instance, mock_context, mock_tool):
-        """Test that {{tool_names}} placeholder is replaced."""
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[mock_tool],
-            context=mock_context,
-        )
-
-        system_content = "Valid actions: {{tool_names}}"
-        messages = [
-            SystemPromptMessage(content=system_content),
-        ]
-
-        result = strategy._build_prompt_with_react_format(messages, [], True)
-
-        assert "{{tool_names}}" not in result[0].content
-        assert '"test_tool"' in result[0].content
-
-    def test_replace_instruction_placeholder(self, mock_model_instance, mock_context):
-        """Test that {{instruction}} placeholder is replaced."""
-        instruction = "You are a helpful coding assistant."
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-            instruction=instruction,
-        )
-
-        system_content = "{{instruction}}\n\nYou have access to: {{tools}}"
-        messages = [
-            SystemPromptMessage(content=system_content),
-        ]
-
-        result = strategy._build_prompt_with_react_format(messages, [], True, instruction)
-
-        assert "{{instruction}}" not in result[0].content
-        assert instruction in result[0].content
-
-    def test_no_tools_available_message(self, mock_model_instance, mock_context):
-        """Test that 'No tools available' is shown when include_tools is False."""
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        system_content = "You have access to: {{tools}}"
-        messages = [
-            SystemPromptMessage(content=system_content),
-        ]
-
-        result = strategy._build_prompt_with_react_format(messages, [], False)
-
-        assert "No tools available" in result[0].content
-
-    def test_scratchpad_appended_as_assistant_message(self, mock_model_instance, mock_context):
-        """Test that agent scratchpad is appended as AssistantPromptMessage."""
-        from core.agent.entities import AgentScratchpadUnit
-        from core.model_runtime.entities import AssistantPromptMessage
-
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        messages = [
-            SystemPromptMessage(content="System prompt"),
-            UserPromptMessage(content="User query"),
-        ]
-
-        scratchpad = [
-            AgentScratchpadUnit(
-                thought="I need to search for information",
-                action_str='{"action": "search", "action_input": "query"}',
-                observation="Search results here",
-            )
-        ]
-
-        result = strategy._build_prompt_with_react_format(messages, scratchpad, True)
-
-        # The last message should be an AssistantPromptMessage with scratchpad content
-        assert len(result) == 3
-        assert isinstance(result[-1], AssistantPromptMessage)
-        assert "I need to search for information" in result[-1].content
-        assert "Search results here" in result[-1].content
-
-    def test_empty_scratchpad_no_extra_message(self, mock_model_instance, mock_context):
-        """Test that empty scratchpad doesn't add extra message."""
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        messages = [
-            SystemPromptMessage(content="System prompt"),
-            UserPromptMessage(content="User query"),
-        ]
-
-        result = strategy._build_prompt_with_react_format(messages, [], True)
-
-        # Should only have the original 2 messages
-        assert len(result) == 2
-
-    def test_original_messages_not_modified(self, mock_model_instance, mock_context):
-        """Test that original messages list is not modified."""
-        strategy = ReActStrategy(
-            model_instance=mock_model_instance,
-            tools=[],
-            context=mock_context,
-        )
-
-        original_content = "Original system prompt {{tools}}"
-        messages = [
-            SystemPromptMessage(content=original_content),
-        ]
-
-        strategy._build_prompt_with_react_format(messages, [], True)
-
-        # Original message should not be modified
-        assert messages[0].content == original_content

api/tests/unit_tests/core/agent/patterns/test_strategy_factory.py

@@ -1,203 +0,0 @@
-"""Tests for StrategyFactory."""
-
-from unittest.mock import MagicMock
-
-import pytest
-
-from core.agent.entities import AgentEntity, ExecutionContext
-from core.agent.patterns.function_call import FunctionCallStrategy
-from core.agent.patterns.react import ReActStrategy
-from core.agent.patterns.strategy_factory import StrategyFactory
-from core.model_runtime.entities.model_entities import ModelFeature
-
-
-@pytest.fixture
-def mock_model_instance():
-    """Create a mock model instance."""
-    model_instance = MagicMock()
-    model_instance.model = "test-model"
-    model_instance.provider = "test-provider"
-    return model_instance
-
-
-@pytest.fixture
-def mock_context():
-    """Create a mock execution context."""
-    return ExecutionContext(
-        user_id="test-user",
-        app_id="test-app",
-        conversation_id="test-conversation",
-        message_id="test-message",
-        tenant_id="test-tenant",
-    )
-
-
-class TestStrategyFactory:
-    """Tests for StrategyFactory.create_strategy method."""
-
-    def test_create_function_call_strategy_with_tool_call_feature(self, mock_model_instance, mock_context):
-        """Test that FunctionCallStrategy is created when model supports TOOL_CALL."""
-        model_features = [ModelFeature.TOOL_CALL]
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-        )
-
-        assert isinstance(strategy, FunctionCallStrategy)
-
-    def test_create_function_call_strategy_with_multi_tool_call_feature(self, mock_model_instance, mock_context):
-        """Test that FunctionCallStrategy is created when model supports MULTI_TOOL_CALL."""
-        model_features = [ModelFeature.MULTI_TOOL_CALL]
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-        )
-
-        assert isinstance(strategy, FunctionCallStrategy)
-
-    def test_create_function_call_strategy_with_stream_tool_call_feature(self, mock_model_instance, mock_context):
-        """Test that FunctionCallStrategy is created when model supports STREAM_TOOL_CALL."""
-        model_features = [ModelFeature.STREAM_TOOL_CALL]
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-        )
-
-        assert isinstance(strategy, FunctionCallStrategy)
-
-    def test_create_react_strategy_without_tool_call_features(self, mock_model_instance, mock_context):
-        """Test that ReActStrategy is created when model doesn't support tool calling."""
-        model_features = [ModelFeature.VISION]  # Only vision, no tool calling
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-        )
-
-        assert isinstance(strategy, ReActStrategy)
-
-    def test_create_react_strategy_with_empty_features(self, mock_model_instance, mock_context):
-        """Test that ReActStrategy is created when model has no features."""
-        model_features: list[ModelFeature] = []
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-        )
-
-        assert isinstance(strategy, ReActStrategy)
-
-    def test_explicit_function_calling_strategy_with_support(self, mock_model_instance, mock_context):
-        """Test explicit FUNCTION_CALLING strategy selection with model support."""
-        model_features = [ModelFeature.TOOL_CALL]
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-            agent_strategy=AgentEntity.Strategy.FUNCTION_CALLING,
-        )
-
-        assert isinstance(strategy, FunctionCallStrategy)
-
-    def test_explicit_function_calling_strategy_without_support_falls_back_to_react(
-        self, mock_model_instance, mock_context
-    ):
-        """Test that explicit FUNCTION_CALLING falls back to ReAct when not supported."""
-        model_features: list[ModelFeature] = []  # No tool calling support
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-            agent_strategy=AgentEntity.Strategy.FUNCTION_CALLING,
-        )
-
-        # Should fall back to ReAct since FC is not supported
-        assert isinstance(strategy, ReActStrategy)
-
-    def test_explicit_chain_of_thought_strategy(self, mock_model_instance, mock_context):
-        """Test explicit CHAIN_OF_THOUGHT strategy selection."""
-        model_features = [ModelFeature.TOOL_CALL]  # Even with tool call support
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-            agent_strategy=AgentEntity.Strategy.CHAIN_OF_THOUGHT,
-        )
-
-        assert isinstance(strategy, ReActStrategy)
-
-    def test_react_strategy_with_instruction(self, mock_model_instance, mock_context):
-        """Test that ReActStrategy receives instruction parameter."""
-        model_features: list[ModelFeature] = []
-        instruction = "You are a helpful assistant."
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-            instruction=instruction,
-        )
-
-        assert isinstance(strategy, ReActStrategy)
-        assert strategy.instruction == instruction
-
-    def test_max_iterations_passed_to_strategy(self, mock_model_instance, mock_context):
-        """Test that max_iterations is passed to the strategy."""
-        model_features = [ModelFeature.TOOL_CALL]
-        max_iterations = 5
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-            max_iterations=max_iterations,
-        )
-
-        assert strategy.max_iterations == max_iterations
-
-    def test_tool_invoke_hook_passed_to_strategy(self, mock_model_instance, mock_context):
-        """Test that tool_invoke_hook is passed to the strategy."""
-        model_features = [ModelFeature.TOOL_CALL]
-        mock_hook = MagicMock()
-
-        strategy = StrategyFactory.create_strategy(
-            model_features=model_features,
-            model_instance=mock_model_instance,
-            context=mock_context,
-            tools=[],
-            files=[],
-            tool_invoke_hook=mock_hook,
-        )
-
-        assert strategy.tool_invoke_hook == mock_hook

api/tests/unit_tests/core/agent/test_agent_app_runner.py

@@ -1,388 +0,0 @@
-"""Tests for AgentAppRunner."""
-
-from decimal import Decimal
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from core.agent.entities import AgentEntity, AgentLog, AgentPromptEntity, AgentResult
-from core.model_runtime.entities import SystemPromptMessage, UserPromptMessage
-from core.model_runtime.entities.llm_entities import LLMUsage
-
-
-class TestOrganizePromptMessages:
-    """Tests for _organize_prompt_messages method."""
-
-    @pytest.fixture
-    def mock_runner(self):
-        """Create a mock AgentAppRunner for testing."""
-        # We'll patch the class to avoid complex initialization
-        with patch("core.agent.agent_app_runner.BaseAgentRunner.__init__", return_value=None):
-            from core.agent.agent_app_runner import AgentAppRunner
-
-            runner = AgentAppRunner.__new__(AgentAppRunner)
-
-            # Set up required attributes
-            runner.config = MagicMock(spec=AgentEntity)
-            runner.config.strategy = AgentEntity.Strategy.FUNCTION_CALLING
-            runner.config.prompt = None
-
-            runner.app_config = MagicMock()
-            runner.app_config.prompt_template = MagicMock()
-            runner.app_config.prompt_template.simple_prompt_template = "You are a helpful assistant."
-
-            runner.history_prompt_messages = []
-            runner.query = "Hello"
-            runner._current_thoughts = []
-            runner.files = []
-            runner.model_config = MagicMock()
-            runner.memory = None
-            runner.application_generate_entity = MagicMock()
-            runner.application_generate_entity.file_upload_config = None
-
-            return runner
-
-    def test_function_calling_uses_simple_prompt(self, mock_runner):
-        """Test that function calling strategy uses simple_prompt_template."""
-        mock_runner.config.strategy = AgentEntity.Strategy.FUNCTION_CALLING
-
-        with patch.object(mock_runner, "_init_system_message") as mock_init:
-            mock_init.return_value = [SystemPromptMessage(content="You are a helpful assistant.")]
-            with patch.object(mock_runner, "_organize_user_query") as mock_query:
-                mock_query.return_value = [UserPromptMessage(content="Hello")]
-                with patch("core.agent.agent_app_runner.AgentHistoryPromptTransform") as mock_transform:
-                    mock_transform.return_value.get_prompt.return_value = [
-                        SystemPromptMessage(content="You are a helpful assistant.")
-                    ]
-
-                    result = mock_runner._organize_prompt_messages()
-
-                    # Verify _init_system_message was called with simple_prompt_template
-                    mock_init.assert_called_once()
-                    call_args = mock_init.call_args[0]
-                    assert call_args[0] == "You are a helpful assistant."
-
-    def test_chain_of_thought_uses_agent_prompt(self, mock_runner):
-        """Test that chain of thought strategy uses agent prompt template."""
-        mock_runner.config.strategy = AgentEntity.Strategy.CHAIN_OF_THOUGHT
-        mock_runner.config.prompt = AgentPromptEntity(
-            first_prompt="ReAct prompt template with {{tools}}",
-            next_iteration="Continue...",
-        )
-
-        with patch.object(mock_runner, "_init_system_message") as mock_init:
-            mock_init.return_value = [SystemPromptMessage(content="ReAct prompt template with {{tools}}")]
-            with patch.object(mock_runner, "_organize_user_query") as mock_query:
-                mock_query.return_value = [UserPromptMessage(content="Hello")]
-                with patch("core.agent.agent_app_runner.AgentHistoryPromptTransform") as mock_transform:
-                    mock_transform.return_value.get_prompt.return_value = [
-                        SystemPromptMessage(content="ReAct prompt template with {{tools}}")
-                    ]
-
-                    result = mock_runner._organize_prompt_messages()
-
-                    # Verify _init_system_message was called with agent prompt
-                    mock_init.assert_called_once()
-                    call_args = mock_init.call_args[0]
-                    assert call_args[0] == "ReAct prompt template with {{tools}}"
-
-    def test_chain_of_thought_without_prompt_falls_back(self, mock_runner):
-        """Test that chain of thought without prompt falls back to simple_prompt_template."""
-        mock_runner.config.strategy = AgentEntity.Strategy.CHAIN_OF_THOUGHT
-        mock_runner.config.prompt = None
-
-        with patch.object(mock_runner, "_init_system_message") as mock_init:
-            mock_init.return_value = [SystemPromptMessage(content="You are a helpful assistant.")]
-            with patch.object(mock_runner, "_organize_user_query") as mock_query:
-                mock_query.return_value = [UserPromptMessage(content="Hello")]
-                with patch("core.agent.agent_app_runner.AgentHistoryPromptTransform") as mock_transform:
-                    mock_transform.return_value.get_prompt.return_value = [
-                        SystemPromptMessage(content="You are a helpful assistant.")
-                    ]
-
-                    result = mock_runner._organize_prompt_messages()
-
-                    # Verify _init_system_message was called with simple_prompt_template
-                    mock_init.assert_called_once()
-                    call_args = mock_init.call_args[0]
-                    assert call_args[0] == "You are a helpful assistant."
-
-
-class TestInitSystemMessage:
-    """Tests for _init_system_message method."""
-
-    @pytest.fixture
-    def mock_runner(self):
-        """Create a mock AgentAppRunner for testing."""
-        with patch("core.agent.agent_app_runner.BaseAgentRunner.__init__", return_value=None):
-            from core.agent.agent_app_runner import AgentAppRunner
-
-            runner = AgentAppRunner.__new__(AgentAppRunner)
-            return runner
-
-    def test_empty_messages_with_template(self, mock_runner):
-        """Test that system message is created when messages are empty."""
-        result = mock_runner._init_system_message("System template", [])
-
-        assert len(result) == 1
-        assert isinstance(result[0], SystemPromptMessage)
-        assert result[0].content == "System template"
-
-    def test_empty_messages_without_template(self, mock_runner):
-        """Test that empty list is returned when no template and no messages."""
-        result = mock_runner._init_system_message("", [])
-
-        assert result == []
-
-    def test_existing_system_message_not_duplicated(self, mock_runner):
-        """Test that system message is not duplicated if already present."""
-        existing_messages = [
-            SystemPromptMessage(content="Existing system"),
-            UserPromptMessage(content="User message"),
-        ]
-
-        result = mock_runner._init_system_message("New template", existing_messages)
-
-        # Should not insert new system message
-        assert len(result) == 2
-        assert result[0].content == "Existing system"
-
-    def test_system_message_inserted_when_missing(self, mock_runner):
-        """Test that system message is inserted when first message is not system."""
-        existing_messages = [
-            UserPromptMessage(content="User message"),
-        ]
-
-        result = mock_runner._init_system_message("System template", existing_messages)
-
-        assert len(result) == 2
-        assert isinstance(result[0], SystemPromptMessage)
-        assert result[0].content == "System template"
-
-
-class TestClearUserPromptImageMessages:
-    """Tests for _clear_user_prompt_image_messages method."""
-
-    @pytest.fixture
-    def mock_runner(self):
-        """Create a mock AgentAppRunner for testing."""
-        with patch("core.agent.agent_app_runner.BaseAgentRunner.__init__", return_value=None):
-            from core.agent.agent_app_runner import AgentAppRunner
-
-            runner = AgentAppRunner.__new__(AgentAppRunner)
-            return runner
-
-    def test_text_content_unchanged(self, mock_runner):
-        """Test that text content is unchanged."""
-        messages = [
-            UserPromptMessage(content="Plain text message"),
-        ]
-
-        result = mock_runner._clear_user_prompt_image_messages(messages)
-
-        assert len(result) == 1
-        assert result[0].content == "Plain text message"
-
-    def test_original_messages_not_modified(self, mock_runner):
-        """Test that original messages are not modified (deep copy)."""
-        from core.model_runtime.entities.message_entities import (
-            ImagePromptMessageContent,
-            TextPromptMessageContent,
-        )
-
-        messages = [
-            UserPromptMessage(
-                content=[
-                    TextPromptMessageContent(data="Text part"),
-                    ImagePromptMessageContent(
-                        data="http://example.com/image.jpg",
-                        format="url",
-                        mime_type="image/jpeg",
-                    ),
-                ]
-            ),
-        ]
-
-        result = mock_runner._clear_user_prompt_image_messages(messages)
-
-        # Original should still have list content
-        assert isinstance(messages[0].content, list)
-        # Result should have string content
-        assert isinstance(result[0].content, str)
-
-
-class TestToolInvokeHook:
-    """Tests for _create_tool_invoke_hook method."""
-
-    @pytest.fixture
-    def mock_runner(self):
-        """Create a mock AgentAppRunner for testing."""
-        with patch("core.agent.agent_app_runner.BaseAgentRunner.__init__", return_value=None):
-            from core.agent.agent_app_runner import AgentAppRunner
-
-            runner = AgentAppRunner.__new__(AgentAppRunner)
-
-            runner.user_id = "test-user"
-            runner.tenant_id = "test-tenant"
-            runner.application_generate_entity = MagicMock()
-            runner.application_generate_entity.trace_manager = None
-            runner.application_generate_entity.invoke_from = "api"
-            runner.application_generate_entity.app_config = MagicMock()
-            runner.application_generate_entity.app_config.app_id = "test-app"
-            runner.agent_callback = MagicMock()
-            runner.conversation = MagicMock()
-            runner.conversation.id = "test-conversation"
-            runner.queue_manager = MagicMock()
-            runner._current_message_file_ids = []
-
-            return runner
-
-    def test_hook_calls_agent_invoke(self, mock_runner):
-        """Test that the hook calls ToolEngine.agent_invoke."""
-        from core.tools.entities.tool_entities import ToolInvokeMeta
-
-        mock_message = MagicMock()
-        mock_message.id = "test-message"
-
-        mock_tool = MagicMock()
-        mock_tool_meta = ToolInvokeMeta(
-            time_cost=0.5,
-            error=None,
-            tool_config={
-                "tool_provider_type": "test_provider",
-                "tool_provider": "test_id",
-            },
-        )
-
-        with patch("core.agent.agent_app_runner.ToolEngine") as mock_engine:
-            mock_engine.agent_invoke.return_value = ("Tool result", ["file-1", "file-2"], mock_tool_meta)
-
-            hook = mock_runner._create_tool_invoke_hook(mock_message)
-            result_content, result_files, result_meta = hook(mock_tool, {"arg": "value"}, "test_tool")
-
-            # Verify ToolEngine.agent_invoke was called
-            mock_engine.agent_invoke.assert_called_once()
-
-            # Verify return values
-            assert result_content == "Tool result"
-            assert result_files == ["file-1", "file-2"]
-            assert result_meta == mock_tool_meta
-
-    def test_hook_publishes_file_events(self, mock_runner):
-        """Test that the hook publishes QueueMessageFileEvent for files."""
-        from core.tools.entities.tool_entities import ToolInvokeMeta
-
-        mock_message = MagicMock()
-        mock_message.id = "test-message"
-
-        mock_tool = MagicMock()
-        mock_tool_meta = ToolInvokeMeta(
-            time_cost=0.5,
-            error=None,
-            tool_config={},
-        )
-
-        with patch("core.agent.agent_app_runner.ToolEngine") as mock_engine:
-            mock_engine.agent_invoke.return_value = ("Tool result", ["file-1", "file-2"], mock_tool_meta)
-
-            hook = mock_runner._create_tool_invoke_hook(mock_message)
-            hook(mock_tool, {}, "test_tool")
-
-            # Verify file events were published
-            assert mock_runner.queue_manager.publish.call_count == 2
-            assert mock_runner._current_message_file_ids == ["file-1", "file-2"]
-
-
-class TestAgentLogProcessing:
-    """Tests for AgentLog processing in run method."""
-
-    def test_agent_log_status_enum(self):
-        """Test AgentLog status enum values."""
-        assert AgentLog.LogStatus.START == "start"
-        assert AgentLog.LogStatus.SUCCESS == "success"
-        assert AgentLog.LogStatus.ERROR == "error"
-
-    def test_agent_log_metadata_enum(self):
-        """Test AgentLog metadata enum values."""
-        assert AgentLog.LogMetadata.STARTED_AT == "started_at"
-        assert AgentLog.LogMetadata.FINISHED_AT == "finished_at"
-        assert AgentLog.LogMetadata.ELAPSED_TIME == "elapsed_time"
-        assert AgentLog.LogMetadata.TOTAL_PRICE == "total_price"
-        assert AgentLog.LogMetadata.TOTAL_TOKENS == "total_tokens"
-        assert AgentLog.LogMetadata.LLM_USAGE == "llm_usage"
-
-    def test_agent_result_structure(self):
-        """Test AgentResult structure."""
-        usage = LLMUsage(
-            prompt_tokens=100,
-            prompt_unit_price=Decimal("0.001"),
-            prompt_price_unit=Decimal("0.001"),
-            prompt_price=Decimal("0.1"),
-            completion_tokens=50,
-            completion_unit_price=Decimal("0.002"),
-            completion_price_unit=Decimal("0.001"),
-            completion_price=Decimal("0.1"),
-            total_tokens=150,
-            total_price=Decimal("0.2"),
-            currency="USD",
-            latency=0.5,
-        )
-
-        result = AgentResult(
-            text="Final answer",
-            files=[],
-            usage=usage,
-            finish_reason="stop",
-        )
-
-        assert result.text == "Final answer"
-        assert result.files == []
-        assert result.usage == usage
-        assert result.finish_reason == "stop"
-
-
-class TestOrganizeUserQuery:
-    """Tests for _organize_user_query method."""
-
-    @pytest.fixture
-    def mock_runner(self):
-        """Create a mock AgentAppRunner for testing."""
-        with patch("core.agent.agent_app_runner.BaseAgentRunner.__init__", return_value=None):
-            from core.agent.agent_app_runner import AgentAppRunner
-
-            runner = AgentAppRunner.__new__(AgentAppRunner)
-            runner.files = []
-            runner.application_generate_entity = MagicMock()
-            runner.application_generate_entity.file_upload_config = None
-            return runner
-
-    def test_simple_query_without_files(self, mock_runner):
-        """Test organizing a simple query without files."""
-        result = mock_runner._organize_user_query("Hello world", [])
-
-        assert len(result) == 1
-        assert isinstance(result[0], UserPromptMessage)
-        assert result[0].content == "Hello world"
-
-    def test_query_with_files(self, mock_runner):
-        """Test organizing a query with files."""
-        from core.file.models import File
-
-        mock_file = MagicMock(spec=File)
-        mock_runner.files = [mock_file]
-
-        with patch("core.agent.agent_app_runner.file_manager") as mock_fm:
-            from core.model_runtime.entities.message_entities import ImagePromptMessageContent
-
-            mock_fm.to_prompt_message_content.return_value = ImagePromptMessageContent(
-                data="http://example.com/image.jpg",
-                format="url",
-                mime_type="image/jpeg",
-            )
-
-            result = mock_runner._organize_user_query("Describe this image", [])
-
-            assert len(result) == 1
-            assert isinstance(result[0], UserPromptMessage)
-            assert isinstance(result[0].content, list)
-            assert len(result[0].content) == 2  # Image + Text

api/tests/unit_tests/core/agent/test_entities.py

@@ -1,191 +0,0 @@
-"""Tests for agent entities."""
-
-from core.agent.entities import AgentEntity, AgentLog, AgentPromptEntity, AgentScratchpadUnit, ExecutionContext
-
-
-class TestExecutionContext:
-    """Tests for ExecutionContext entity."""
-
-    def test_create_with_all_fields(self):
-        """Test creating ExecutionContext with all fields."""
-        context = ExecutionContext(
-            user_id="user-123",
-            app_id="app-456",
-            conversation_id="conv-789",
-            message_id="msg-012",
-            tenant_id="tenant-345",
-        )
-
-        assert context.user_id == "user-123"
-        assert context.app_id == "app-456"
-        assert context.conversation_id == "conv-789"
-        assert context.message_id == "msg-012"
-        assert context.tenant_id == "tenant-345"
-
-    def test_create_minimal(self):
-        """Test creating minimal ExecutionContext."""
-        context = ExecutionContext.create_minimal(user_id="user-123")
-
-        assert context.user_id == "user-123"
-        assert context.app_id is None
-        assert context.conversation_id is None
-        assert context.message_id is None
-        assert context.tenant_id is None
-
-    def test_to_dict(self):
-        """Test converting ExecutionContext to dictionary."""
-        context = ExecutionContext(
-            user_id="user-123",
-            app_id="app-456",
-            conversation_id="conv-789",
-            message_id="msg-012",
-            tenant_id="tenant-345",
-        )
-
-        result = context.to_dict()
-
-        assert result == {
-            "user_id": "user-123",
-            "app_id": "app-456",
-            "conversation_id": "conv-789",
-            "message_id": "msg-012",
-            "tenant_id": "tenant-345",
-        }
-
-    def test_with_updates(self):
-        """Test creating new context with updates."""
-        original = ExecutionContext(
-            user_id="user-123",
-            app_id="app-456",
-        )
-
-        updated = original.with_updates(message_id="msg-789")
-
-        # Original should be unchanged
-        assert original.message_id is None
-        # Updated should have new value
-        assert updated.message_id == "msg-789"
-        assert updated.user_id == "user-123"
-        assert updated.app_id == "app-456"
-
-
-class TestAgentLog:
-    """Tests for AgentLog entity."""
-
-    def test_create_log_with_required_fields(self):
-        """Test creating AgentLog with required fields."""
-        log = AgentLog(
-            label="ROUND 1",
-            log_type=AgentLog.LogType.ROUND,
-            status=AgentLog.LogStatus.START,
-            data={"key": "value"},
-        )
-
-        assert log.label == "ROUND 1"
-        assert log.log_type == AgentLog.LogType.ROUND
-        assert log.status == AgentLog.LogStatus.START
-        assert log.data == {"key": "value"}
-        assert log.id is not None  # Auto-generated
-        assert log.parent_id is None
-        assert log.error is None
-
-    def test_log_type_enum(self):
-        """Test LogType enum values."""
-        assert AgentLog.LogType.ROUND == "round"
-        assert AgentLog.LogType.THOUGHT == "thought"
-        assert AgentLog.LogType.TOOL_CALL == "tool_call"
-
-    def test_log_status_enum(self):
-        """Test LogStatus enum values."""
-        assert AgentLog.LogStatus.START == "start"
-        assert AgentLog.LogStatus.SUCCESS == "success"
-        assert AgentLog.LogStatus.ERROR == "error"
-
-    def test_log_metadata_enum(self):
-        """Test LogMetadata enum values."""
-        assert AgentLog.LogMetadata.STARTED_AT == "started_at"
-        assert AgentLog.LogMetadata.FINISHED_AT == "finished_at"
-        assert AgentLog.LogMetadata.ELAPSED_TIME == "elapsed_time"
-        assert AgentLog.LogMetadata.TOTAL_PRICE == "total_price"
-        assert AgentLog.LogMetadata.TOTAL_TOKENS == "total_tokens"
-        assert AgentLog.LogMetadata.LLM_USAGE == "llm_usage"
-
-
-class TestAgentScratchpadUnit:
-    """Tests for AgentScratchpadUnit entity."""
-
-    def test_is_final_with_final_answer_action(self):
-        """Test is_final returns True for Final Answer action."""
-        unit = AgentScratchpadUnit(
-            thought="I know the answer",
-            action=AgentScratchpadUnit.Action(
-                action_name="Final Answer",
-                action_input="The answer is 42",
-            ),
-        )
-
-        assert unit.is_final() is True
-
-    def test_is_final_with_tool_action(self):
-        """Test is_final returns False for tool action."""
-        unit = AgentScratchpadUnit(
-            thought="I need to search",
-            action=AgentScratchpadUnit.Action(
-                action_name="search",
-                action_input={"query": "test"},
-            ),
-        )
-
-        assert unit.is_final() is False
-
-    def test_is_final_with_no_action(self):
-        """Test is_final returns True when no action."""
-        unit = AgentScratchpadUnit(
-            thought="Just thinking",
-        )
-
-        assert unit.is_final() is True
-
-    def test_action_to_dict(self):
-        """Test Action.to_dict method."""
-        action = AgentScratchpadUnit.Action(
-            action_name="search",
-            action_input={"query": "test"},
-        )
-
-        result = action.to_dict()
-
-        assert result == {
-            "action": "search",
-            "action_input": {"query": "test"},
-        }
-
-
-class TestAgentEntity:
-    """Tests for AgentEntity."""
-
-    def test_strategy_enum(self):
-        """Test Strategy enum values."""
-        assert AgentEntity.Strategy.CHAIN_OF_THOUGHT == "chain-of-thought"
-        assert AgentEntity.Strategy.FUNCTION_CALLING == "function-calling"
-
-    def test_create_with_prompt(self):
-        """Test creating AgentEntity with prompt."""
-        prompt = AgentPromptEntity(
-            first_prompt="You are a helpful assistant.",
-            next_iteration="Continue thinking...",
-        )
-
-        entity = AgentEntity(
-            provider="openai",
-            model="gpt-4",
-            strategy=AgentEntity.Strategy.CHAIN_OF_THOUGHT,
-            prompt=prompt,
-            max_iteration=5,
-        )
-
-        assert entity.provider == "openai"
-        assert entity.model == "gpt-4"
-        assert entity.strategy == AgentEntity.Strategy.CHAIN_OF_THOUGHT
-        assert entity.prompt == prompt
-        assert entity.max_iteration == 5

api/tests/unit_tests/core/app/apps/test_workflow_app_runner_stream_chunk.py

@@ -1,47 +0,0 @@
-from unittest.mock import MagicMock
-
-from core.app.apps.base_app_queue_manager import PublishFrom
-from core.app.apps.workflow_app_runner import WorkflowBasedAppRunner
-from core.workflow.graph_events import NodeRunStreamChunkEvent
-from core.workflow.nodes import NodeType
-
-
-class DummyQueueManager:
-    def __init__(self) -> None:
-        self.published = []
-
-    def publish(self, event, publish_from: PublishFrom) -> None:
-        self.published.append((event, publish_from))
-
-
-def test_skip_empty_final_chunk() -> None:
-    queue_manager = DummyQueueManager()
-    runner = WorkflowBasedAppRunner(queue_manager=queue_manager, app_id="app")
-
-    empty_final_event = NodeRunStreamChunkEvent(
-        id="exec",
-        node_id="node",
-        node_type=NodeType.LLM,
-        selector=["node", "text"],
-        chunk="",
-        is_final=True,
-    )
-
-    runner._handle_event(workflow_entry=MagicMock(), event=empty_final_event)
-    assert queue_manager.published == []
-
-    normal_event = NodeRunStreamChunkEvent(
-        id="exec",
-        node_id="node",
-        node_type=NodeType.LLM,
-        selector=["node", "text"],
-        chunk="hi",
-        is_final=False,
-    )
-
-    runner._handle_event(workflow_entry=MagicMock(), event=normal_event)
-
-    assert len(queue_manager.published) == 1
-    published_event, publish_from = queue_manager.published[0]
-    assert publish_from == PublishFrom.APPLICATION_MANAGER
-    assert published_event.text == "hi"

api/tests/unit_tests/core/workflow/graph_engine/test_response_coordinator.py

@@ -1,231 +0,0 @@
-"""Tests for ResponseStreamCoordinator object field streaming."""
-
-from unittest.mock import MagicMock
-
-from core.workflow.entities.tool_entities import ToolResultStatus
-from core.workflow.enums import NodeType
-from core.workflow.graph.graph import Graph
-from core.workflow.graph_engine.response_coordinator.coordinator import ResponseStreamCoordinator
-from core.workflow.graph_engine.response_coordinator.session import ResponseSession
-from core.workflow.graph_events import (
-    ChunkType,
-    NodeRunStreamChunkEvent,
-    ToolCall,
-    ToolResult,
-)
-from core.workflow.nodes.base.entities import BaseNodeData
-from core.workflow.nodes.base.template import Template, VariableSegment
-from core.workflow.runtime import VariablePool
-
-
-class TestResponseCoordinatorObjectStreaming:
-    """Test streaming of object-type variables with child fields."""
-
-    def test_object_field_streaming(self):
-        """Test that when selecting an object variable, all child field streams are forwarded."""
-        # Create mock graph and variable pool
-        graph = MagicMock(spec=Graph)
-        variable_pool = MagicMock(spec=VariablePool)
-
-        # Mock nodes
-        llm_node = MagicMock()
-        llm_node.id = "llm_node"
-        llm_node.node_type = NodeType.LLM
-        llm_node.execution_type = MagicMock()
-        llm_node.blocks_variable_output = MagicMock(return_value=False)
-
-        response_node = MagicMock()
-        response_node.id = "response_node"
-        response_node.node_type = NodeType.ANSWER
-        response_node.execution_type = MagicMock()
-        response_node.blocks_variable_output = MagicMock(return_value=False)
-
-        # Mock template for response node
-        response_node.node_data = MagicMock(spec=BaseNodeData)
-        response_node.node_data.answer = "{{#llm_node.generation#}}"
-
-        graph.nodes = {
-            "llm_node": llm_node,
-            "response_node": response_node,
-        }
-        graph.root_node = llm_node
-        graph.get_outgoing_edges = MagicMock(return_value=[])
-
-        # Create coordinator
-        coordinator = ResponseStreamCoordinator(variable_pool, graph)
-
-        # Track execution
-        coordinator.track_node_execution("llm_node", "exec_123")
-        coordinator.track_node_execution("response_node", "exec_456")
-
-        # Simulate streaming events for child fields of generation object
-        # 1. Content stream
-        content_event_1 = NodeRunStreamChunkEvent(
-            id="exec_123",
-            node_id="llm_node",
-            node_type=NodeType.LLM,
-            selector=["llm_node", "generation", "content"],
-            chunk="Hello",
-            is_final=False,
-            chunk_type=ChunkType.TEXT,
-        )
-        content_event_2 = NodeRunStreamChunkEvent(
-            id="exec_123",
-            node_id="llm_node",
-            node_type=NodeType.LLM,
-            selector=["llm_node", "generation", "content"],
-            chunk=" world",
-            is_final=True,
-            chunk_type=ChunkType.TEXT,
-        )
-
-        # 2. Tool call stream
-        tool_call_event = NodeRunStreamChunkEvent(
-            id="exec_123",
-            node_id="llm_node",
-            node_type=NodeType.LLM,
-            selector=["llm_node", "generation", "tool_calls"],
-            chunk='{"query": "test"}',
-            is_final=True,
-            chunk_type=ChunkType.TOOL_CALL,
-            tool_call=ToolCall(
-                id="call_123",
-                name="search",
-                arguments='{"query": "test"}',
-            ),
-        )
-
-        # 3. Tool result stream
-        tool_result_event = NodeRunStreamChunkEvent(
-            id="exec_123",
-            node_id="llm_node",
-            node_type=NodeType.LLM,
-            selector=["llm_node", "generation", "tool_results"],
-            chunk="Found 10 results",
-            is_final=True,
-            chunk_type=ChunkType.TOOL_RESULT,
-            tool_result=ToolResult(
-                id="call_123",
-                name="search",
-                output="Found 10 results",
-                files=[],
-                status=ToolResultStatus.SUCCESS,
-            ),
-        )
-
-        # Intercept these events
-        coordinator.intercept_event(content_event_1)
-        coordinator.intercept_event(tool_call_event)
-        coordinator.intercept_event(tool_result_event)
-        coordinator.intercept_event(content_event_2)
-
-        # Verify that all child streams are buffered
-        assert ("llm_node", "generation", "content") in coordinator._stream_buffers
-        assert ("llm_node", "generation", "tool_calls") in coordinator._stream_buffers
-        assert ("llm_node", "generation", "tool_results") in coordinator._stream_buffers
-
-        # Verify payloads are preserved in buffered events
-        buffered_call = coordinator._stream_buffers[("llm_node", "generation", "tool_calls")][0]
-        assert buffered_call.tool_call is not None
-        assert buffered_call.tool_call.id == "call_123"
-        buffered_result = coordinator._stream_buffers[("llm_node", "generation", "tool_results")][0]
-        assert buffered_result.tool_result is not None
-        assert buffered_result.tool_result.status == "success"
-
-        # Verify we can find child streams
-        child_streams = coordinator._find_child_streams(["llm_node", "generation"])
-        assert len(child_streams) == 3
-        assert ("llm_node", "generation", "content") in child_streams
-        assert ("llm_node", "generation", "tool_calls") in child_streams
-        assert ("llm_node", "generation", "tool_results") in child_streams
-
-    def test_find_child_streams(self):
-        """Test the _find_child_streams method."""
-        graph = MagicMock(spec=Graph)
-        variable_pool = MagicMock(spec=VariablePool)
-
-        coordinator = ResponseStreamCoordinator(variable_pool, graph)
-
-        # Add some mock streams
-        coordinator._stream_buffers = {
-            ("node1", "generation", "content"): [],
-            ("node1", "generation", "tool_calls"): [],
-            ("node1", "generation", "thought"): [],
-            ("node1", "text"): [],  # Not a child of generation
-            ("node2", "generation", "content"): [],  # Different node
-        }
-
-        # Find children of node1.generation
-        children = coordinator._find_child_streams(["node1", "generation"])
-
-        assert len(children) == 3
-        assert ("node1", "generation", "content") in children
-        assert ("node1", "generation", "tool_calls") in children
-        assert ("node1", "generation", "thought") in children
-        assert ("node1", "text") not in children
-        assert ("node2", "generation", "content") not in children
-
-    def test_find_child_streams_with_closed_streams(self):
-        """Test that _find_child_streams also considers closed streams."""
-        graph = MagicMock(spec=Graph)
-        variable_pool = MagicMock(spec=VariablePool)
-
-        coordinator = ResponseStreamCoordinator(variable_pool, graph)
-
-        # Add some streams - some buffered, some closed
-        coordinator._stream_buffers = {
-            ("node1", "generation", "content"): [],
-        }
-        coordinator._closed_streams = {
-            ("node1", "generation", "tool_calls"),
-            ("node1", "generation", "thought"),
-        }
-
-        # Should find all children regardless of whether they're in buffers or closed
-        children = coordinator._find_child_streams(["node1", "generation"])
-
-        assert len(children) == 3
-        assert ("node1", "generation", "content") in children
-        assert ("node1", "generation", "tool_calls") in children
-        assert ("node1", "generation", "thought") in children
-
-    def test_special_selector_rewrites_to_active_response_node(self):
-        """Ensure special selectors attribute streams to the active response node."""
-        graph = MagicMock(spec=Graph)
-        variable_pool = MagicMock(spec=VariablePool)
-
-        response_node = MagicMock()
-        response_node.id = "response_node"
-        response_node.node_type = NodeType.ANSWER
-        graph.nodes = {"response_node": response_node}
-        graph.root_node = response_node
-
-        coordinator = ResponseStreamCoordinator(variable_pool, graph)
-        coordinator.track_node_execution("response_node", "exec_resp")
-
-        coordinator._active_session = ResponseSession(
-            node_id="response_node",
-            template=Template(segments=[VariableSegment(selector=["sys", "foo"])]),
-        )
-
-        event = NodeRunStreamChunkEvent(
-            id="stream_1",
-            node_id="llm_node",
-            node_type=NodeType.LLM,
-            selector=["sys", "foo"],
-            chunk="hi",
-            is_final=True,
-            chunk_type=ChunkType.TEXT,
-        )
-
-        coordinator._stream_buffers[("sys", "foo")] = [event]
-        coordinator._stream_positions[("sys", "foo")] = 0
-        coordinator._closed_streams.add(("sys", "foo"))
-
-        events, is_complete = coordinator._process_variable_segment(VariableSegment(selector=["sys", "foo"]))
-
-        assert is_complete
-        assert len(events) == 1
-        rewritten = events[0]
-        assert rewritten.node_id == "response_node"
-        assert rewritten.id == "exec_resp"

api/tests/unit_tests/core/workflow/node_events/test_stream_chunk_events.py

@@ -1,328 +0,0 @@
-"""Tests for StreamChunkEvent and its subclasses."""
-
-from core.workflow.entities import ToolCall, ToolResult, ToolResultStatus
-from core.workflow.node_events import (
-    ChunkType,
-    StreamChunkEvent,
-    ThoughtChunkEvent,
-    ToolCallChunkEvent,
-    ToolResultChunkEvent,
-)
-
-
-class TestChunkType:
-    """Tests for ChunkType enum."""
-
-    def test_chunk_type_values(self):
-        """Test that ChunkType has expected values."""
-        assert ChunkType.TEXT == "text"
-        assert ChunkType.TOOL_CALL == "tool_call"
-        assert ChunkType.TOOL_RESULT == "tool_result"
-        assert ChunkType.THOUGHT == "thought"
-
-    def test_chunk_type_is_str_enum(self):
-        """Test that ChunkType values are strings."""
-        for chunk_type in ChunkType:
-            assert isinstance(chunk_type.value, str)
-
-
-class TestStreamChunkEvent:
-    """Tests for base StreamChunkEvent."""
-
-    def test_create_with_required_fields(self):
-        """Test creating StreamChunkEvent with required fields."""
-        event = StreamChunkEvent(
-            selector=["node1", "text"],
-            chunk="Hello",
-        )
-
-        assert event.selector == ["node1", "text"]
-        assert event.chunk == "Hello"
-        assert event.is_final is False
-        assert event.chunk_type == ChunkType.TEXT
-
-    def test_create_with_all_fields(self):
-        """Test creating StreamChunkEvent with all fields."""
-        event = StreamChunkEvent(
-            selector=["node1", "output"],
-            chunk="World",
-            is_final=True,
-            chunk_type=ChunkType.TEXT,
-        )
-
-        assert event.selector == ["node1", "output"]
-        assert event.chunk == "World"
-        assert event.is_final is True
-        assert event.chunk_type == ChunkType.TEXT
-
-    def test_default_chunk_type_is_text(self):
-        """Test that default chunk_type is TEXT."""
-        event = StreamChunkEvent(
-            selector=["node1", "text"],
-            chunk="test",
-        )
-
-        assert event.chunk_type == ChunkType.TEXT
-
-    def test_serialization(self):
-        """Test that event can be serialized to dict."""
-        event = StreamChunkEvent(
-            selector=["node1", "text"],
-            chunk="Hello",
-            is_final=True,
-        )
-
-        data = event.model_dump()
-
-        assert data["selector"] == ["node1", "text"]
-        assert data["chunk"] == "Hello"
-        assert data["is_final"] is True
-        assert data["chunk_type"] == "text"
-
-
-class TestToolCallChunkEvent:
-    """Tests for ToolCallChunkEvent."""
-
-    def test_create_with_required_fields(self):
-        """Test creating ToolCallChunkEvent with required fields."""
-        event = ToolCallChunkEvent(
-            selector=["node1", "tool_calls"],
-            chunk='{"city": "Beijing"}',
-            tool_call=ToolCall(id="call_123", name="weather", arguments=None),
-        )
-
-        assert event.selector == ["node1", "tool_calls"]
-        assert event.chunk == '{"city": "Beijing"}'
-        assert event.tool_call.id == "call_123"
-        assert event.tool_call.name == "weather"
-        assert event.chunk_type == ChunkType.TOOL_CALL
-
-    def test_chunk_type_is_tool_call(self):
-        """Test that chunk_type is always TOOL_CALL."""
-        event = ToolCallChunkEvent(
-            selector=["node1", "tool_calls"],
-            chunk="",
-            tool_call=ToolCall(id="call_123", name="test_tool", arguments=None),
-        )
-
-        assert event.chunk_type == ChunkType.TOOL_CALL
-
-    def test_tool_arguments_field(self):
-        """Test tool_arguments field."""
-        event = ToolCallChunkEvent(
-            selector=["node1", "tool_calls"],
-            chunk='{"param": "value"}',
-            tool_call=ToolCall(
-                id="call_123",
-                name="test_tool",
-                arguments='{"param": "value"}',
-            ),
-        )
-
-        assert event.tool_call.arguments == '{"param": "value"}'
-
-    def test_serialization(self):
-        """Test that event can be serialized to dict."""
-        event = ToolCallChunkEvent(
-            selector=["node1", "tool_calls"],
-            chunk='{"city": "Beijing"}',
-            tool_call=ToolCall(
-                id="call_123",
-                name="weather",
-                arguments='{"city": "Beijing"}',
-            ),
-            is_final=True,
-        )
-
-        data = event.model_dump()
-
-        assert data["chunk_type"] == "tool_call"
-        assert data["tool_call"]["id"] == "call_123"
-        assert data["tool_call"]["name"] == "weather"
-        assert data["tool_call"]["arguments"] == '{"city": "Beijing"}'
-        assert data["is_final"] is True
-
-
-class TestToolResultChunkEvent:
-    """Tests for ToolResultChunkEvent."""
-
-    def test_create_with_required_fields(self):
-        """Test creating ToolResultChunkEvent with required fields."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="Weather: Sunny, 25°C",
-            tool_result=ToolResult(id="call_123", name="weather", output="Weather: Sunny, 25°C"),
-        )
-
-        assert event.selector == ["node1", "tool_results"]
-        assert event.chunk == "Weather: Sunny, 25°C"
-        assert event.tool_result.id == "call_123"
-        assert event.tool_result.name == "weather"
-        assert event.chunk_type == ChunkType.TOOL_RESULT
-
-    def test_chunk_type_is_tool_result(self):
-        """Test that chunk_type is always TOOL_RESULT."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="result",
-            tool_result=ToolResult(id="call_123", name="test_tool"),
-        )
-
-        assert event.chunk_type == ChunkType.TOOL_RESULT
-
-    def test_tool_files_default_empty(self):
-        """Test that tool_files defaults to empty list."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="result",
-            tool_result=ToolResult(id="call_123", name="test_tool"),
-        )
-
-        assert event.tool_result.files == []
-
-    def test_tool_files_with_values(self):
-        """Test tool_files with file IDs."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="result",
-            tool_result=ToolResult(
-                id="call_123",
-                name="test_tool",
-                files=["file_1", "file_2"],
-            ),
-        )
-
-        assert event.tool_result.files == ["file_1", "file_2"]
-
-    def test_tool_error_output(self):
-        """Test error output captured in tool_result."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="",
-            tool_result=ToolResult(
-                id="call_123",
-                name="test_tool",
-                output="Tool execution failed",
-                status=ToolResultStatus.ERROR,
-            ),
-        )
-
-        assert event.tool_result.output == "Tool execution failed"
-        assert event.tool_result.status == ToolResultStatus.ERROR
-
-    def test_serialization(self):
-        """Test that event can be serialized to dict."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="Weather: Sunny",
-            tool_result=ToolResult(
-                id="call_123",
-                name="weather",
-                output="Weather: Sunny",
-                files=["file_1"],
-                status=ToolResultStatus.SUCCESS,
-            ),
-            is_final=True,
-        )
-
-        data = event.model_dump()
-
-        assert data["chunk_type"] == "tool_result"
-        assert data["tool_result"]["id"] == "call_123"
-        assert data["tool_result"]["name"] == "weather"
-        assert data["tool_result"]["files"] == ["file_1"]
-        assert data["is_final"] is True
-
-
-class TestThoughtChunkEvent:
-    """Tests for ThoughtChunkEvent."""
-
-    def test_create_with_required_fields(self):
-        """Test creating ThoughtChunkEvent with required fields."""
-        event = ThoughtChunkEvent(
-            selector=["node1", "thought"],
-            chunk="I need to query the weather...",
-        )
-
-        assert event.selector == ["node1", "thought"]
-        assert event.chunk == "I need to query the weather..."
-        assert event.chunk_type == ChunkType.THOUGHT
-
-    def test_chunk_type_is_thought(self):
-        """Test that chunk_type is always THOUGHT."""
-        event = ThoughtChunkEvent(
-            selector=["node1", "thought"],
-            chunk="thinking...",
-        )
-
-        assert event.chunk_type == ChunkType.THOUGHT
-
-    def test_serialization(self):
-        """Test that event can be serialized to dict."""
-        event = ThoughtChunkEvent(
-            selector=["node1", "thought"],
-            chunk="I need to analyze this...",
-            is_final=False,
-        )
-
-        data = event.model_dump()
-
-        assert data["chunk_type"] == "thought"
-        assert data["chunk"] == "I need to analyze this..."
-        assert data["is_final"] is False
-
-
-class TestEventInheritance:
-    """Tests for event inheritance relationships."""
-
-    def test_tool_call_is_stream_chunk(self):
-        """Test that ToolCallChunkEvent is a StreamChunkEvent."""
-        event = ToolCallChunkEvent(
-            selector=["node1", "tool_calls"],
-            chunk="",
-            tool_call=ToolCall(id="call_123", name="test", arguments=None),
-        )
-
-        assert isinstance(event, StreamChunkEvent)
-
-    def test_tool_result_is_stream_chunk(self):
-        """Test that ToolResultChunkEvent is a StreamChunkEvent."""
-        event = ToolResultChunkEvent(
-            selector=["node1", "tool_results"],
-            chunk="result",
-            tool_result=ToolResult(id="call_123", name="test"),
-        )
-
-        assert isinstance(event, StreamChunkEvent)
-
-    def test_thought_is_stream_chunk(self):
-        """Test that ThoughtChunkEvent is a StreamChunkEvent."""
-        event = ThoughtChunkEvent(
-            selector=["node1", "thought"],
-            chunk="thinking...",
-        )
-
-        assert isinstance(event, StreamChunkEvent)
-
-    def test_all_events_have_common_fields(self):
-        """Test that all events have common StreamChunkEvent fields."""
-        events = [
-            StreamChunkEvent(selector=["n", "t"], chunk="a"),
-            ToolCallChunkEvent(
-                selector=["n", "t"],
-                chunk="b",
-                tool_call=ToolCall(id="1", name="t", arguments=None),
-            ),
-            ToolResultChunkEvent(
-                selector=["n", "t"],
-                chunk="c",
-                tool_result=ToolResult(id="1", name="t"),
-            ),
-            ThoughtChunkEvent(selector=["n", "t"], chunk="d"),
-        ]
-
-        for event in events:
-            assert hasattr(event, "selector")
-            assert hasattr(event, "chunk")
-            assert hasattr(event, "is_final")
-            assert hasattr(event, "chunk_type")

api/tests/unit_tests/core/workflow/nodes/test_llm_node_streaming.py

@@ -1,148 +0,0 @@
-import types
-from collections.abc import Generator
-from typing import Any
-
-import pytest
-
-from core.model_runtime.entities.llm_entities import LLMUsage
-from core.workflow.entities import ToolCallResult
-from core.workflow.entities.tool_entities import ToolResultStatus
-from core.workflow.node_events import ModelInvokeCompletedEvent, NodeEventBase
-from core.workflow.nodes.llm.node import LLMNode
-
-
-class _StubModelInstance:
-    """Minimal stub to satisfy _stream_llm_events signature."""
-
-    provider_model_bundle = None
-
-
-def _drain(generator: Generator[NodeEventBase, None, Any]):
-    events: list = []
-    try:
-        while True:
-            events.append(next(generator))
-    except StopIteration as exc:
-        return events, exc.value
-
-
-@pytest.fixture(autouse=True)
-def patch_deduct_llm_quota(monkeypatch):
-    # Avoid touching real quota logic during unit tests
-    monkeypatch.setattr("core.workflow.nodes.llm.node.llm_utils.deduct_llm_quota", lambda **_: None)
-
-
-def _make_llm_node(reasoning_format: str) -> LLMNode:
-    node = LLMNode.__new__(LLMNode)
-    object.__setattr__(node, "_node_data", types.SimpleNamespace(reasoning_format=reasoning_format, tools=[]))
-    object.__setattr__(node, "tenant_id", "tenant")
-    return node
-
-
-def test_stream_llm_events_extracts_reasoning_for_tagged():
-    node = _make_llm_node(reasoning_format="tagged")
-    tagged_text = "<think>Thought</think>Answer"
-    usage = LLMUsage.empty_usage()
-
-    def generator():
-        yield ModelInvokeCompletedEvent(
-            text=tagged_text,
-            usage=usage,
-            finish_reason="stop",
-            reasoning_content="",
-            structured_output=None,
-        )
-
-    events, returned = _drain(
-        node._stream_llm_events(generator(), model_instance=types.SimpleNamespace(provider_model_bundle=None))
-    )
-
-    assert events == []
-    clean_text, reasoning_content, gen_reasoning, gen_clean, ret_usage, finish_reason, structured, gen_data = returned
-    assert clean_text == tagged_text  # original preserved for output
-    assert reasoning_content == ""  # tagged mode keeps reasoning separate
-    assert gen_clean == "Answer"  # stripped content for generation
-    assert gen_reasoning == "Thought"  # reasoning extracted from <think> tag
-    assert ret_usage == usage
-    assert finish_reason == "stop"
-    assert structured is None
-    assert gen_data is None
-
-    # generation building should include reasoning and sequence
-    generation_content = gen_clean or clean_text
-    sequence = [
-        {"type": "reasoning", "index": 0},
-        {"type": "content", "start": 0, "end": len(generation_content)},
-    ]
-    assert sequence == [
-        {"type": "reasoning", "index": 0},
-        {"type": "content", "start": 0, "end": len("Answer")},
-    ]
-
-
-def test_stream_llm_events_no_reasoning_results_in_empty_sequence():
-    node = _make_llm_node(reasoning_format="tagged")
-    plain_text = "Hello world"
-    usage = LLMUsage.empty_usage()
-
-    def generator():
-        yield ModelInvokeCompletedEvent(
-            text=plain_text,
-            usage=usage,
-            finish_reason=None,
-            reasoning_content="",
-            structured_output=None,
-        )
-
-    events, returned = _drain(
-        node._stream_llm_events(generator(), model_instance=types.SimpleNamespace(provider_model_bundle=None))
-    )
-
-    assert events == []
-    _, _, gen_reasoning, gen_clean, *_ = returned
-    generation_content = gen_clean or plain_text
-    assert gen_reasoning == ""
-    assert generation_content == plain_text
-    # Empty reasoning should imply empty sequence in generation construction
-    sequence = []
-    assert sequence == []
-
-
-def test_serialize_tool_call_strips_files_to_ids():
-    file_cls = pytest.importorskip("core.file").File
-    file_type = pytest.importorskip("core.file.enums").FileType
-    transfer_method = pytest.importorskip("core.file.enums").FileTransferMethod
-
-    file_with_id = file_cls(
-        id="f1",
-        tenant_id="t",
-        type=file_type.IMAGE,
-        transfer_method=transfer_method.REMOTE_URL,
-        remote_url="http://example.com/f1",
-        storage_key="k1",
-    )
-    file_with_related = file_cls(
-        id=None,
-        tenant_id="t",
-        type=file_type.IMAGE,
-        transfer_method=transfer_method.REMOTE_URL,
-        related_id="rel2",
-        remote_url="http://example.com/f2",
-        storage_key="k2",
-    )
-    tool_call = ToolCallResult(
-        id="tc",
-        name="do",
-        arguments='{"a":1}',
-        output="ok",
-        files=[file_with_id, file_with_related],
-        status=ToolResultStatus.SUCCESS,
-    )
-
-    serialized = LLMNode._serialize_tool_call(tool_call)
-
-    assert serialized["files"] == ["f1", "rel2"]
-    assert serialized["id"] == "tc"
-    assert serialized["name"] == "do"
-    assert serialized["arguments"] == '{"a":1}'
-    assert serialized["output"] == "ok"

api/tests/unit_tests/services/test_account_service.py

@@ -619,8 +619,13 @@ class TestTenantService:
                 mock_tenant_instance.name = "Test User's Workspace"
                 mock_tenant_class.return_value = mock_tenant_instance
 
-                # Execute test
-                TenantService.create_owner_tenant_if_not_exist(mock_account)
+                # Mock the db import in CreditPoolService to avoid database connection
+                with patch("services.credit_pool_service.db") as mock_credit_pool_db:
+                    mock_credit_pool_db.session.add = MagicMock()
+                    mock_credit_pool_db.session.commit = MagicMock()
+
+                    # Execute test
+                    TenantService.create_owner_tenant_if_not_exist(mock_account)
 
         # Verify tenant was created with correct parameters
         mock_db_dependencies["db"].session.add.assert_called()

web/app/(commonLayout)/plugins/page.tsx

@@ -2,11 +2,11 @@ import Marketplace from '@/app/components/plugins/marketplace'
 import PluginPage from '@/app/components/plugins/plugin-page'
 import PluginsPanel from '@/app/components/plugins/plugin-page/plugins-panel'
 
-const PluginList = async () => {
+const PluginList = () => {
   return (
     <PluginPage
       plugins={<PluginsPanel />}
-      marketplace={<Marketplace pluginTypeSwitchClassName="top-[60px]" showSearchParams={false} />}
+      marketplace={<Marketplace pluginTypeSwitchClassName="top-[60px]" />}
     />
   )
 }

web/app/(shareLayout)/webapp-signin/check-code/page.tsx

@@ -8,12 +8,12 @@ import Button from '@/app/components/base/button'
 import Input from '@/app/components/base/input'
 import Toast from '@/app/components/base/toast'
 import Countdown from '@/app/components/signin/countdown'
-
 import { useLocale } from '@/context/i18n'
 import { useWebAppStore } from '@/context/web-app-context'
 import { sendWebAppEMailLoginCode, webAppEmailLoginWithCode } from '@/service/common'
 import { fetchAccessToken } from '@/service/share'
 import { setWebAppAccessToken, setWebAppPassport } from '@/service/webapp-auth'
+import { encryptVerificationCode } from '@/utils/encryption'
 
 export default function CheckCode() {
   const { t } = useTranslation()
@@ -64,7 +64,7 @@ export default function CheckCode() {
         return
       }
       setIsLoading(true)
-      const ret = await webAppEmailLoginWithCode({ email, code, token })
+      const ret = await webAppEmailLoginWithCode({ email, code: encryptVerificationCode(code), token })
       if (ret.result === 'success') {
         setWebAppAccessToken(ret.data.access_token)
         const { access_token } = await fetchAccessToken({

web/app/(shareLayout)/webapp-signin/components/mail-and-password-auth.tsx

@@ -13,6 +13,7 @@ import { useWebAppStore } from '@/context/web-app-context'
 import { webAppLogin } from '@/service/common'
 import { fetchAccessToken } from '@/service/share'
 import { setWebAppAccessToken, setWebAppPassport } from '@/service/webapp-auth'
+import { encryptPassword } from '@/utils/encryption'
 
 type MailAndPasswordAuthProps = {
   isEmailSetup: boolean
@@ -71,7 +72,7 @@ export default function MailAndPasswordAuth({ isEmailSetup }: MailAndPasswordAut
       setIsLoading(true)
       const loginData: Record<string, any> = {
         email,
-        password,
+        password: encryptPassword(password),
         language: locale,
         remember_me: true,
       }

web/app/components/app-sidebar/app-info.tsx

@@ -26,6 +26,7 @@ import { NEED_REFRESH_APP_LIST_KEY } from '@/config'
 import { useAppContext } from '@/context/app-context'
 import { useProviderContext } from '@/context/provider-context'
 import { copyApp, deleteApp, exportAppConfig, updateAppInfo } from '@/service/apps'
+import { useInvalidateAppList } from '@/service/use-apps'
 import { fetchWorkflowDraft } from '@/service/workflow'
 import { AppModeEnum } from '@/types/app'
 import { getRedirection } from '@/utils/app-redirection'
@@ -66,6 +67,7 @@ const AppInfo = ({ expand, onlyShowDetail = false, openState = false, onDetailEx
   const { onPlanInfoChanged } = useProviderContext()
   const appDetail = useAppStore(state => state.appDetail)
   const setAppDetail = useAppStore(state => state.setAppDetail)
+  const invalidateAppList = useInvalidateAppList()
   const [open, setOpen] = useState(openState)
   const [showEditModal, setShowEditModal] = useState(false)
   const [showDuplicateModal, setShowDuplicateModal] = useState(false)
@@ -191,6 +193,7 @@ const AppInfo = ({ expand, onlyShowDetail = false, openState = false, onDetailEx
     try {
       await deleteApp(appDetail.id)
       notify({ type: 'success', message: t('appDeleted', { ns: 'app' }) })
+      invalidateAppList()
       onPlanInfoChanged()
       setAppDetail()
       replace('/apps')
@@ -202,7 +205,7 @@ const AppInfo = ({ expand, onlyShowDetail = false, openState = false, onDetailEx
       })
     }
     setShowConfirmDelete(false)
-  }, [appDetail, notify, onPlanInfoChanged, replace, setAppDetail, t])
+  }, [appDetail, invalidateAppList, notify, onPlanInfoChanged, replace, setAppDetail, t])
 
   const { isCurrentWorkspaceEditor } = useAppContext()
 

web/app/components/app/log/list.spec.tsx

@@ -0,0 +1,228 @@
+/**
+ * Tests for race condition prevention logic in chat message loading.
+ * These tests verify the core algorithms used in fetchData and loadMoreMessages
+ * to prevent race conditions, infinite loops, and stale state issues.
+ * See GitHub issue #30259 for context.
+ */
+
+// Test the race condition prevention logic in isolation
+describe('Chat Message Loading Race Condition Prevention', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  describe('Request Deduplication', () => {
+    it('should deduplicate messages with same IDs when merging responses', async () => {
+      // Simulate the deduplication logic used in setAllChatItems
+      const existingItems = [
+        { id: 'msg-1', isAnswer: false },
+        { id: 'msg-2', isAnswer: true },
+      ]
+      const newItems = [
+        { id: 'msg-2', isAnswer: true }, // duplicate
+        { id: 'msg-3', isAnswer: false }, // new
+      ]
+
+      const existingIds = new Set(existingItems.map(item => item.id))
+      const uniqueNewItems = newItems.filter(item => !existingIds.has(item.id))
+      const mergedItems = [...uniqueNewItems, ...existingItems]
+
+      expect(uniqueNewItems).toHaveLength(1)
+      expect(uniqueNewItems[0].id).toBe('msg-3')
+      expect(mergedItems).toHaveLength(3)
+    })
+  })
+
+  describe('Retry Counter Logic', () => {
+    const MAX_RETRY_COUNT = 3
+
+    it('should increment retry counter when no unique items found', () => {
+      const state = { retryCount: 0 }
+      const prevItemsLength = 5
+
+      // Simulate the retry logic from loadMoreMessages
+      const uniqueNewItemsLength = 0
+
+      if (uniqueNewItemsLength === 0) {
+        if (state.retryCount < MAX_RETRY_COUNT && prevItemsLength > 1) {
+          state.retryCount++
+        }
+        else {
+          state.retryCount = 0
+        }
+      }
+
+      expect(state.retryCount).toBe(1)
+    })
+
+    it('should reset retry counter after MAX_RETRY_COUNT attempts', () => {
+      const state = { retryCount: MAX_RETRY_COUNT }
+      const prevItemsLength = 5
+      const uniqueNewItemsLength = 0
+
+      if (uniqueNewItemsLength === 0) {
+        if (state.retryCount < MAX_RETRY_COUNT && prevItemsLength > 1) {
+          state.retryCount++
+        }
+        else {
+          state.retryCount = 0
+        }
+      }
+
+      expect(state.retryCount).toBe(0)
+    })
+
+    it('should reset retry counter when unique items are found', () => {
+      const state = { retryCount: 2 }
+
+      // Simulate finding unique items (length > 0)
+      const processRetry = (uniqueCount: number) => {
+        if (uniqueCount === 0) {
+          state.retryCount++
+        }
+        else {
+          state.retryCount = 0
+        }
+      }
+
+      processRetry(3) // Found 3 unique items
+
+      expect(state.retryCount).toBe(0)
+    })
+  })
+
+  describe('Throttling Logic', () => {
+    const SCROLL_DEBOUNCE_MS = 200
+
+    it('should throttle requests within debounce window', () => {
+      const state = { lastLoadTime: 0 }
+      const results: boolean[] = []
+
+      const tryRequest = (now: number): boolean => {
+        if (now - state.lastLoadTime >= SCROLL_DEBOUNCE_MS) {
+          state.lastLoadTime = now
+          return true
+        }
+        return false
+      }
+
+      // First request - should pass
+      results.push(tryRequest(1000))
+      // Second request within debounce - should be blocked
+      results.push(tryRequest(1100))
+      // Third request after debounce - should pass
+      results.push(tryRequest(1300))
+
+      expect(results).toEqual([true, false, true])
+    })
+  })
+
+  describe('AbortController Cancellation', () => {
+    it('should abort previous request when new request starts', () => {
+      const state: { controller: AbortController | null } = { controller: null }
+      const abortedSignals: boolean[] = []
+
+      // First request
+      const controller1 = new AbortController()
+      state.controller = controller1
+
+      // Second request - should abort first
+      if (state.controller) {
+        state.controller.abort()
+        abortedSignals.push(state.controller.signal.aborted)
+      }
+      const controller2 = new AbortController()
+      state.controller = controller2
+
+      expect(abortedSignals).toEqual([true])
+      expect(controller1.signal.aborted).toBe(true)
+      expect(controller2.signal.aborted).toBe(false)
+    })
+  })
+
+  describe('Stale Response Detection', () => {
+    it('should ignore responses from outdated requests', () => {
+      const state = { requestId: 0 }
+      const processedResponses: number[] = []
+
+      // Simulate concurrent requests - each gets its own captured ID
+      const request1Id = ++state.requestId
+      const request2Id = ++state.requestId
+
+      // Request 2 completes first (current requestId is 2)
+      if (request2Id === state.requestId) {
+        processedResponses.push(request2Id)
+      }
+
+      // Request 1 completes later (stale - requestId is still 2)
+      if (request1Id === state.requestId) {
+        processedResponses.push(request1Id)
+      }
+
+      expect(processedResponses).toEqual([2])
+      expect(processedResponses).not.toContain(1)
+    })
+  })
+
+  describe('Pagination Anchor Management', () => {
+    it('should track oldest answer ID for pagination', () => {
+      let oldestAnswerIdRef: string | undefined
+
+      const chatItems = [
+        { id: 'question-1', isAnswer: false },
+        { id: 'answer-1', isAnswer: true },
+        { id: 'question-2', isAnswer: false },
+        { id: 'answer-2', isAnswer: true },
+      ]
+
+      // Update pagination anchor with oldest answer ID
+      const answerItems = chatItems.filter(item => item.isAnswer)
+      const oldestAnswer = answerItems[answerItems.length - 1]
+      if (oldestAnswer?.id) {
+        oldestAnswerIdRef = oldestAnswer.id
+      }
+
+      expect(oldestAnswerIdRef).toBe('answer-2')
+    })
+
+    it('should use pagination anchor in subsequent requests', () => {
+      const oldestAnswerIdRef = 'answer-123'
+      const params: { conversation_id: string, limit: number, first_id?: string } = {
+        conversation_id: 'conv-1',
+        limit: 10,
+      }
+
+      if (oldestAnswerIdRef) {
+        params.first_id = oldestAnswerIdRef
+      }
+
+      expect(params.first_id).toBe('answer-123')
+    })
+  })
+})
+
+describe('Functional State Update Pattern', () => {
+  it('should use functional update to avoid stale closures', () => {
+    // Simulate the functional update pattern used in setAllChatItems
+    let state = [{ id: '1' }, { id: '2' }]
+
+    const newItems = [{ id: '3' }, { id: '2' }] // id '2' is duplicate
+
+    // Functional update pattern
+    const updater = (prevItems: { id: string }[]) => {
+      const existingIds = new Set(prevItems.map(item => item.id))
+      const uniqueNewItems = newItems.filter(item => !existingIds.has(item.id))
+      return [...uniqueNewItems, ...prevItems]
+    }
+
+    state = updater(state)
+
+    expect(state).toHaveLength(3)
+    expect(state.map(i => i.id)).toEqual(['3', '1', '2'])
+  })
+})

web/app/components/app/log/list.tsx

@@ -209,7 +209,6 @@ type IDetailPanel = {
 
 function DetailPanel({ detail, onFeedback }: IDetailPanel) {
   const MIN_ITEMS_FOR_SCROLL_LOADING = 8
-  const SCROLL_THRESHOLD_PX = 50
   const SCROLL_DEBOUNCE_MS = 200
   const { userProfile: { timezone } } = useAppContext()
   const { formatTime } = useTimestamp()
@@ -228,69 +227,103 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
   const [hasMore, setHasMore] = useState(true)
   const [varValues, setVarValues] = useState<Record<string, string>>({})
   const isLoadingRef = useRef(false)
+  const abortControllerRef = useRef<AbortController | null>(null)
+  const requestIdRef = useRef(0)
+  const lastLoadTimeRef = useRef(0)
+  const retryCountRef = useRef(0)
+  const oldestAnswerIdRef = useRef<string | undefined>(undefined)
+  const MAX_RETRY_COUNT = 3
 
   const [allChatItems, setAllChatItems] = useState<IChatItem[]>([])
   const [chatItemTree, setChatItemTree] = useState<ChatItemInTree[]>([])
   const [threadChatItems, setThreadChatItems] = useState<IChatItem[]>([])
 
   const fetchData = useCallback(async () => {
-    if (isLoadingRef.current)
+    if (isLoadingRef.current || !hasMore)
       return
 
+    // Cancel any in-flight request
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort()
+    }
+
+    const controller = new AbortController()
+    abortControllerRef.current = controller
+    const currentRequestId = ++requestIdRef.current
+
     try {
       isLoadingRef.current = true
 
-      if (!hasMore)
-        return
-
       const params: ChatMessagesRequest = {
         conversation_id: detail.id,
         limit: 10,
       }
-      // Use the oldest answer item ID for pagination
-      const answerItems = allChatItems.filter(item => item.isAnswer)
-      const oldestAnswerItem = answerItems[answerItems.length - 1]
-      if (oldestAnswerItem?.id)
-        params.first_id = oldestAnswerItem.id
+      // Use ref for pagination anchor to avoid stale closure issues
+      if (oldestAnswerIdRef.current)
+        params.first_id = oldestAnswerIdRef.current
+
       const messageRes = await fetchChatMessages({
         url: `/apps/${appDetail?.id}/chat-messages`,
         params,
       })
+
+      // Ignore stale responses
+      if (currentRequestId !== requestIdRef.current || controller.signal.aborted)
+        return
       if (messageRes.data.length > 0) {
         const varValues = messageRes.data.at(-1)!.inputs
         setVarValues(varValues)
       }
       setHasMore(messageRes.has_more)
 
-      const newAllChatItems = [
-        ...getFormattedChatList(messageRes.data, detail.id, timezone!, t('dateTimeFormat', { ns: 'appLog' }) as string),
-        ...allChatItems,
-      ]
-      setAllChatItems(newAllChatItems)
+      const newItems = getFormattedChatList(messageRes.data, detail.id, timezone!, t('dateTimeFormat', { ns: 'appLog' }) as string)
 
-      let tree = buildChatItemTree(newAllChatItems)
-      if (messageRes.has_more === false && detail?.model_config?.configs?.introduction) {
-        tree = [{
-          id: 'introduction',
-          isAnswer: true,
-          isOpeningStatement: true,
-          content: detail?.model_config?.configs?.introduction ?? 'hello',
-          feedbackDisabled: true,
-          children: tree,
-        }]
-      }
-      setChatItemTree(tree)
-
-      const lastMessageId = newAllChatItems.length > 0 ? newAllChatItems[newAllChatItems.length - 1].id : undefined
-      setThreadChatItems(getThreadMessages(tree, lastMessageId))
+      // Use functional update to avoid stale state issues
+      setAllChatItems((prevItems: IChatItem[]) => {
+        const existingIds = new Set(prevItems.map(item => item.id))
+        const uniqueNewItems = newItems.filter(item => !existingIds.has(item.id))
+        return [...uniqueNewItems, ...prevItems]
+      })
     }
-    catch (err) {
+    catch (err: unknown) {
+      if (err instanceof Error && err.name === 'AbortError')
+        return
       console.error('fetchData execution failed:', err)
     }
     finally {
       isLoadingRef.current = false
+      if (abortControllerRef.current === controller)
+        abortControllerRef.current = null
     }
-  }, [allChatItems, detail.id, hasMore, timezone, t, appDetail, detail?.model_config?.configs?.introduction])
+  }, [detail.id, hasMore, timezone, t, appDetail, detail?.model_config?.configs?.introduction])
+
+  // Derive chatItemTree, threadChatItems, and oldestAnswerIdRef from allChatItems
+  useEffect(() => {
+    if (allChatItems.length === 0)
+      return
+
+    let tree = buildChatItemTree(allChatItems)
+    if (!hasMore && detail?.model_config?.configs?.introduction) {
+      tree = [{
+        id: 'introduction',
+        isAnswer: true,
+        isOpeningStatement: true,
+        content: detail?.model_config?.configs?.introduction ?? 'hello',
+        feedbackDisabled: true,
+        children: tree,
+      }]
+    }
+    setChatItemTree(tree)
+
+    const lastMessageId = allChatItems.length > 0 ? allChatItems[allChatItems.length - 1].id : undefined
+    setThreadChatItems(getThreadMessages(tree, lastMessageId))
+
+    // Update pagination anchor ref with the oldest answer ID
+    const answerItems = allChatItems.filter(item => item.isAnswer)
+    const oldestAnswer = answerItems[answerItems.length - 1]
+    if (oldestAnswer?.id)
+      oldestAnswerIdRef.current = oldestAnswer.id
+  }, [allChatItems, hasMore, detail?.model_config?.configs?.introduction])
 
   const switchSibling = useCallback((siblingMessageId: string) => {
     const newThreadChatItems = getThreadMessages(chatItemTree, siblingMessageId)
@@ -397,6 +430,12 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
     if (isLoading || !hasMore || !appDetail?.id || !detail.id)
       return
 
+    // Throttle using ref to persist across re-renders
+    const now = Date.now()
+    if (now - lastLoadTimeRef.current < SCROLL_DEBOUNCE_MS)
+      return
+    lastLoadTimeRef.current = now
+
     setIsLoading(true)
 
     try {
@@ -405,15 +444,9 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
         limit: 10,
       }
 
-      // Use the earliest response item as the first_id
-      const answerItems = allChatItems.filter(item => item.isAnswer)
-      const oldestAnswerItem = answerItems[answerItems.length - 1]
-      if (oldestAnswerItem?.id) {
-        params.first_id = oldestAnswerItem.id
-      }
-      else if (allChatItems.length > 0 && allChatItems[0]?.id) {
-        const firstId = allChatItems[0].id.replace('question-', '').replace('answer-', '')
-        params.first_id = firstId
+      // Use ref for pagination anchor to avoid stale closure issues
+      if (oldestAnswerIdRef.current) {
+        params.first_id = oldestAnswerIdRef.current
       }
 
       const messageRes = await fetchChatMessages({
@@ -423,6 +456,7 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
 
       if (!messageRes.data || messageRes.data.length === 0) {
         setHasMore(false)
+        retryCountRef.current = 0
         return
       }
 
@@ -440,91 +474,36 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
         t('dateTimeFormat', { ns: 'appLog' }) as string,
       )
 
-      // Check for duplicate messages
-      const existingIds = new Set(allChatItems.map(item => item.id))
-      const uniqueNewItems = newItems.filter(item => !existingIds.has(item.id))
+      // Use functional update to get latest state and avoid stale closures
+      setAllChatItems((prevItems: IChatItem[]) => {
+        const existingIds = new Set(prevItems.map(item => item.id))
+        const uniqueNewItems = newItems.filter(item => !existingIds.has(item.id))
 
-      if (uniqueNewItems.length === 0) {
-        if (allChatItems.length > 1) {
-          const nextId = allChatItems[1].id.replace('question-', '').replace('answer-', '')
-
-          const retryParams = {
-            ...params,
-            first_id: nextId,
+        // If no unique items and we haven't exceeded retry limit, signal retry needed
+        if (uniqueNewItems.length === 0) {
+          if (retryCountRef.current < MAX_RETRY_COUNT && prevItems.length > 1) {
+            retryCountRef.current++
+            return prevItems
           }
-
-          const retryRes = await fetchChatMessages({
-            url: `/apps/${appDetail.id}/chat-messages`,
-            params: retryParams,
-          })
-
-          if (retryRes.data && retryRes.data.length > 0) {
-            const retryItems = getFormattedChatList(
-              retryRes.data,
-              detail.id,
-              timezone!,
-              t('dateTimeFormat', { ns: 'appLog' }) as string,
-            )
-
-            const retryUniqueItems = retryItems.filter(item => !existingIds.has(item.id))
-            if (retryUniqueItems.length > 0) {
-              const newAllChatItems = [
-                ...retryUniqueItems,
-                ...allChatItems,
-              ]
-
-              setAllChatItems(newAllChatItems)
-
-              let tree = buildChatItemTree(newAllChatItems)
-              if (retryRes.has_more === false && detail?.model_config?.configs?.introduction) {
-                tree = [{
-                  id: 'introduction',
-                  isAnswer: true,
-                  isOpeningStatement: true,
-                  content: detail?.model_config?.configs?.introduction ?? 'hello',
-                  feedbackDisabled: true,
-                  children: tree,
-                }]
-              }
-              setChatItemTree(tree)
-              setHasMore(retryRes.has_more)
-              setThreadChatItems(getThreadMessages(tree, newAllChatItems.at(-1)?.id))
-              return
-            }
+          else {
+            retryCountRef.current = 0
+            return prevItems
           }
         }
-      }
 
-      const newAllChatItems = [
-        ...uniqueNewItems,
-        ...allChatItems,
-      ]
-
-      setAllChatItems(newAllChatItems)
-
-      let tree = buildChatItemTree(newAllChatItems)
-      if (messageRes.has_more === false && detail?.model_config?.configs?.introduction) {
-        tree = [{
-          id: 'introduction',
-          isAnswer: true,
-          isOpeningStatement: true,
-          content: detail?.model_config?.configs?.introduction ?? 'hello',
-          feedbackDisabled: true,
-          children: tree,
-        }]
-      }
-      setChatItemTree(tree)
-
-      setThreadChatItems(getThreadMessages(tree, newAllChatItems.at(-1)?.id))
+        retryCountRef.current = 0
+        return [...uniqueNewItems, ...prevItems]
+      })
     }
     catch (error) {
       console.error(error)
       setHasMore(false)
+      retryCountRef.current = 0
     }
     finally {
       setIsLoading(false)
     }
-  }, [allChatItems, detail.id, hasMore, isLoading, timezone, t, appDetail])
+  }, [detail.id, hasMore, isLoading, timezone, t, appDetail, detail?.model_config?.configs?.introduction])
 
   useEffect(() => {
     const scrollableDiv = document.getElementById('scrollableDiv')
@@ -556,24 +535,11 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
     if (!scrollContainer)
       return
 
-    let lastLoadTime = 0
-    const throttleDelay = 200
-
     const handleScroll = () => {
       const currentScrollTop = scrollContainer!.scrollTop
-      const scrollHeight = scrollContainer!.scrollHeight
-      const clientHeight = scrollContainer!.clientHeight
+      const isNearTop = currentScrollTop < 30
 
-      const distanceFromTop = currentScrollTop
-      const distanceFromBottom = scrollHeight - currentScrollTop - clientHeight
-
-      const now = Date.now()
-
-      const isNearTop = distanceFromTop < 30
-      // eslint-disable-next-line sonarjs/no-unused-vars
-      const _distanceFromBottom = distanceFromBottom < 30
-      if (isNearTop && hasMore && !isLoading && (now - lastLoadTime > throttleDelay)) {
-        lastLoadTime = now
+      if (isNearTop && hasMore && !isLoading) {
         loadMoreMessages()
       }
     }
@@ -619,36 +585,6 @@ function DetailPanel({ detail, onFeedback }: IDetailPanel) {
     return () => cancelAnimationFrame(raf)
   }, [])
 
-  // Add scroll listener to ensure loading is triggered
-  useEffect(() => {
-    if (threadChatItems.length >= MIN_ITEMS_FOR_SCROLL_LOADING && hasMore) {
-      const scrollableDiv = document.getElementById('scrollableDiv')
-
-      if (scrollableDiv) {
-        let loadingTimeout: NodeJS.Timeout | null = null
-
-        const handleScroll = () => {
-          const { scrollTop } = scrollableDiv
-
-          // Trigger loading when scrolling near the top
-          if (scrollTop < SCROLL_THRESHOLD_PX && !isLoadingRef.current) {
-            if (loadingTimeout)
-              clearTimeout(loadingTimeout)
-
-            loadingTimeout = setTimeout(fetchData, SCROLL_DEBOUNCE_MS) // 200ms debounce
-          }
-        }
-
-        scrollableDiv.addEventListener('scroll', handleScroll)
-        return () => {
-          scrollableDiv.removeEventListener('scroll', handleScroll)
-          if (loadingTimeout)
-            clearTimeout(loadingTimeout)
-        }
-      }
-    }
-  }, [threadChatItems.length, hasMore, fetchData])
-
   return (
     <div ref={ref} className="flex h-full flex-col rounded-xl border-[0.5px] border-components-panel-border">
       {/* Panel Header */}

web/app/components/apps/list.spec.tsx

@@ -10,6 +10,7 @@ const mockReplace = vi.fn()
 const mockRouter = { replace: mockReplace }
 vi.mock('next/navigation', () => ({
   useRouter: () => mockRouter,
+  useSearchParams: () => new URLSearchParams(''),
 }))
 
 // Mock app context

web/app/components/apps/list.tsx

@@ -12,6 +12,7 @@ import { useDebounceFn } from 'ahooks'
 import dynamic from 'next/dynamic'
 import {
   useRouter,
+  useSearchParams,
 } from 'next/navigation'
 import { parseAsString, useQueryState } from 'nuqs'
 import { useCallback, useEffect, useRef, useState } from 'react'
@@ -36,6 +37,16 @@ import useAppsQueryState from './hooks/use-apps-query-state'
 import { useDSLDragDrop } from './hooks/use-dsl-drag-drop'
 import NewAppCard from './new-app-card'
 
+// Define valid tabs at module scope to avoid re-creation on each render and stale closures
+const validTabs = new Set<string | AppModeEnum>([
+  'all',
+  AppModeEnum.WORKFLOW,
+  AppModeEnum.ADVANCED_CHAT,
+  AppModeEnum.CHAT,
+  AppModeEnum.AGENT_CHAT,
+  AppModeEnum.COMPLETION,
+])
+
 const TagManagementModal = dynamic(() => import('@/app/components/base/tag-management'), {
   ssr: false,
 })
@@ -47,12 +58,41 @@ const List = () => {
   const { t } = useTranslation()
   const { systemFeatures } = useGlobalPublicStore()
   const router = useRouter()
+  const searchParams = useSearchParams()
   const { isCurrentWorkspaceEditor, isCurrentWorkspaceDatasetOperator, isLoadingCurrentWorkspace } = useAppContext()
   const showTagManagementModal = useTagStore(s => s.showTagManagementModal)
   const [activeTab, setActiveTab] = useQueryState(
     'category',
     parseAsString.withDefault('all').withOptions({ history: 'push' }),
   )
+
+  // valid tabs for apps list; anything else should fallback to 'all'
+
+  // 1) Normalize legacy/incorrect query params like ?mode=discover -> ?category=all
+  useEffect(() => {
+    // avoid running on server
+    if (typeof window === 'undefined')
+      return
+    const mode = searchParams.get('mode')
+    if (!mode)
+      return
+    const url = new URL(window.location.href)
+    url.searchParams.delete('mode')
+    if (validTabs.has(mode)) {
+      // migrate to category key
+      url.searchParams.set('category', mode)
+    }
+    else {
+      url.searchParams.set('category', 'all')
+    }
+    router.replace(url.pathname + url.search)
+  }, [router, searchParams])
+
+  // 2) If category has an invalid value (e.g., 'discover'), reset to 'all'
+  useEffect(() => {
+    if (!validTabs.has(activeTab))
+      setActiveTab('all')
+  }, [activeTab, setActiveTab])
   const { query: { tagIDs = [], keywords = '', isCreatedByMe: queryIsCreatedByMe = false }, setQuery } = useAppsQueryState()
   const [isCreatedByMe, setIsCreatedByMe] = useState(queryIsCreatedByMe)
   const [tagFilterValue, setTagFilterValue] = useState<string[]>(tagIDs)

web/app/components/base/chat/embedded-chatbot/header/index.tsx

@@ -66,7 +66,9 @@ const Header: FC<IHeaderProps> = ({
     const listener = (event: MessageEvent) => handleMessageReceived(event)
     window.addEventListener('message', listener)
 
-    window.parent.postMessage({ type: 'dify-chatbot-iframe-ready' }, '*')
+    // Security: Use document.referrer to get parent origin
+    const targetOrigin = document.referrer ? new URL(document.referrer).origin : '*'
+    window.parent.postMessage({ type: 'dify-chatbot-iframe-ready' }, targetOrigin)
 
     return () => window.removeEventListener('message', listener)
   }, [isIframe, handleMessageReceived])

web/app/components/base/features/new-feature-panel/text-to-speech/param-config-content.tsx

@@ -1,7 +1,6 @@
 'use client'
 import type { OnFeaturesChange } from '@/app/components/base/features/types'
 import type { Item } from '@/app/components/base/select'
-import type { I18nKeysWithPrefix } from '@/types/i18n'
 import { Listbox, ListboxButton, ListboxOption, ListboxOptions, Transition } from '@headlessui/react'
 import { CheckIcon, ChevronDownIcon } from '@heroicons/react/20/solid'
 import { RiCloseLine } from '@remixicon/react'
@@ -20,8 +19,6 @@ import { useAppVoices } from '@/service/use-apps'
 import { TtsAutoPlay } from '@/types/app'
 import { cn } from '@/utils/classnames'
 
-type VoiceLanguageKey = I18nKeysWithPrefix<'common', 'voice.language.'>
-
 type VoiceParamConfigProps = {
   onClose: () => void
   onChange?: OnFeaturesChange

web/app/components/base/icons/assets/public/llm/Tongyi.svg

@@ -0,0 +1,17 @@
+<svg width="25" height="25" viewBox="0 0 25 25" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g clip-path="url(#clip0_6305_73327)">
+<path d="M0.5 12.5C0.5 8.77247 0.5 6.9087 1.10896 5.43853C1.92092 3.47831 3.47831 1.92092 5.43853 1.10896C6.9087 0.5 8.77247 0.5 12.5 0.5C16.2275 0.5 18.0913 0.5 19.5615 1.10896C21.5217 1.92092 23.0791 3.47831 23.891 5.43853C24.5 6.9087 24.5 8.77247 24.5 12.5C24.5 16.2275 24.5 18.0913 23.891 19.5615C23.0791 21.5217 21.5217 23.0791 19.5615 23.891C18.0913 24.5 16.2275 24.5 12.5 24.5C8.77247 24.5 6.9087 24.5 5.43853 23.891C3.47831 23.0791 1.92092 21.5217 1.10896 19.5615C0.5 18.0913 0.5 16.2275 0.5 12.5Z" fill="white"/>
+<rect width="24" height="24" transform="translate(0.5 0.5)" fill="url(#pattern0_6305_73327)"/>
+<rect width="24" height="24" transform="translate(0.5 0.5)" fill="white" fill-opacity="0.01"/>
+</g>
+<path d="M12.5 0.25C14.3603 0.25 15.7684 0.250313 16.8945 0.327148C18.0228 0.404144 18.8867 0.558755 19.6572 0.87793C21.6787 1.71525 23.2847 3.32133 24.1221 5.34277C24.4412 6.11333 24.5959 6.97723 24.6729 8.10547C24.7497 9.23161 24.75 10.6397 24.75 12.5C24.75 14.3603 24.7497 15.7684 24.6729 16.8945C24.5959 18.0228 24.4412 18.8867 24.1221 19.6572C23.2847 21.6787 21.6787 23.2847 19.6572 24.1221C18.8867 24.4412 18.0228 24.5959 16.8945 24.6729C15.7684 24.7497 14.3603 24.75 12.5 24.75C10.6397 24.75 9.23161 24.7497 8.10547 24.6729C6.97723 24.5959 6.11333 24.4412 5.34277 24.1221C3.32133 23.2847 1.71525 21.6787 0.87793 19.6572C0.558755 18.8867 0.404144 18.0228 0.327148 16.8945C0.250313 15.7684 0.25 14.3603 0.25 12.5C0.25 10.6397 0.250313 9.23161 0.327148 8.10547C0.404144 6.97723 0.558755 6.11333 0.87793 5.34277C1.71525 3.32133 3.32133 1.71525 5.34277 0.87793C6.11333 0.558755 6.97723 0.404144 8.10547 0.327148C9.23161 0.250313 10.6397 0.25 12.5 0.25Z" stroke="#101828" stroke-opacity="0.08" stroke-width="0.5"/>
+<defs>
+<pattern id="pattern0_6305_73327" patternContentUnits="objectBoundingBox" width="1" height="1">
+<use xlink:href="#image0_6305_73327" transform="scale(0.00625)"/>
+</pattern>
+<clipPath id="clip0_6305_73327">
+<path d="M0.5 12.5C0.5 8.77247 0.5 6.9087 1.10896 5.43853C1.92092 3.47831 3.47831 1.92092 5.43853 1.10896C6.9087 0.5 8.77247 0.5 12.5 0.5C16.2275 0.5 18.0913 0.5 19.5615 1.10896C21.5217 1.92092 23.0791 3.47831 23.891 5.43853C24.5 6.9087 24.5 8.77247 24.5 12.5C24.5 16.2275 24.5 18.0913 23.891 19.5615C23.0791 21.5217 21.5217 23.0791 19.5615 23.891C18.0913 24.5 16.2275 24.5 12.5 24.5C8.77247 24.5 6.9087 24.5 5.43853 23.891C3.47831 23.0791 1.92092 21.5217 1.10896 19.5615C0.5 18.0913 0.5 16.2275 0.5 12.5Z" fill="white"/>
+</clipPath>
+<image id="image0_6305_73327" width="160" height="160" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>
+</defs>
+</svg>

web/app/components/base/icons/assets/public/llm/anthropic-short-light.svg

@@ -0,0 +1,4 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="40" height="40" fill="white"/>
+<path d="M25.7926 10.1311H21.5089L29.3208 29.869H33.6045L25.7926 10.1311ZM13.4164 10.1311L5.60449 29.869H9.97273L11.5703 25.724H19.743L21.3405 29.869H25.7087L17.8969 10.1311H13.4164ZM12.9834 22.0583L15.6566 15.1217L18.3299 22.0583H12.9834Z" fill="black"/>
+</svg>

web/app/components/base/icons/assets/public/llm/deepseek.svg

@@ -0,0 +1,4 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="40" height="40" fill="white"/>
+<path d="M36.6676 11.2917C36.3316 11.1277 36.1871 11.4402 35.9906 11.599C35.9242 11.6511 35.8668 11.7188 35.8108 11.7787C35.3199 12.3048 34.747 12.6485 33.9996 12.6068C32.9046 12.5469 31.971 12.8907 31.1455 13.7293C30.9696 12.6954 30.3863 12.0782 29.4996 11.6824C29.0348 11.4766 28.5647 11.2709 28.2406 10.823C28.0127 10.5053 27.9515 10.1511 27.8368 9.80214C27.7652 9.59121 27.6923 9.37506 27.4502 9.33861C27.1871 9.29694 27.0843 9.51829 26.9814 9.70318C26.5674 10.4584 26.4084 11.2917 26.4228 12.1355C26.4592 14.0313 27.26 15.5417 28.8486 16.6173C29.0296 16.7397 29.0764 16.8646 29.0191 17.0443C28.9111 17.4141 28.7822 17.7735 28.6676 18.1433C28.596 18.3803 28.4879 18.4323 28.2354 18.3282C27.363 17.9637 26.609 17.4246 25.9436 16.7709C24.8135 15.6771 23.7914 14.4689 22.5166 13.5235C22.2171 13.3021 21.919 13.0964 21.609 12.9011C20.3082 11.6355 21.7796 10.5964 22.1194 10.474C22.4762 10.3464 22.2431 9.9037 21.092 9.90891C19.9423 9.91413 18.889 10.2995 17.5478 10.8126C17.3512 10.8907 17.1455 10.948 16.9332 10.9922C15.7158 10.7631 14.4515 10.711 13.1298 10.8594C10.6428 11.1381 8.65587 12.3152 7.19493 14.3255C5.44102 16.7397 5.02826 19.4845 5.53347 22.349C6.06473 25.3646 7.60249 27.8646 9.96707 29.8178C12.4176 31.8413 15.2406 32.8334 18.4606 32.6433C20.4163 32.5313 22.5947 32.2683 25.0504 30.1875C25.6702 30.4949 26.3199 30.6173 27.3994 30.711C28.2302 30.7891 29.0296 30.6694 29.6494 30.5417C30.6194 30.3361 30.5518 29.4375 30.2015 29.2709C27.3578 27.9454 27.9814 28.4845 27.4136 28.0495C28.859 26.3361 31.0374 24.5574 31.889 18.797C31.9554 18.3386 31.898 18.0522 31.889 17.6798C31.8838 17.4558 31.9346 17.3673 32.1923 17.3413C32.9046 17.2605 33.596 17.0651 34.2314 16.7137C36.0739 15.7058 36.816 14.0522 36.9918 12.0678C37.0179 11.7657 36.9866 11.4506 36.6676 11.2917ZM20.613 29.1485C17.8564 26.9793 16.5204 26.2657 15.9684 26.297C15.4527 26.3255 15.5452 26.9167 15.6584 27.3022C15.777 27.6823 15.9319 27.9454 16.1494 28.2787C16.2991 28.5001 16.402 28.8307 15.9996 29.0755C15.1116 29.6277 13.5687 28.8907 13.4958 28.8542C11.7001 27.797 10.1988 26.3985 9.14025 24.487C8.11941 22.6459 7.52566 20.6719 7.42801 18.5651C7.40197 18.0547 7.5517 17.875 8.05691 17.7839C8.72227 17.6615 9.40978 17.6355 10.0751 17.7318C12.8876 18.1433 15.2822 19.4037 17.2887 21.3959C18.4346 22.5339 19.3018 23.8907 20.195 25.2162C21.1442 26.6251 22.1663 27.9662 23.4671 29.0651C23.9254 29.4506 24.2926 29.7449 24.6428 29.961C23.5856 30.0782 21.8199 30.1042 20.613 29.1485ZM21.9332 20.6407C21.9332 20.4141 22.1142 20.2345 22.342 20.2345C22.3928 20.2345 22.4398 20.2449 22.4814 20.2605C22.5374 20.2813 22.5895 20.3126 22.6299 20.3594C22.7027 20.4298 22.7444 20.5339 22.7444 20.6407C22.7444 20.8673 22.5635 21.047 22.3368 21.047C22.109 21.047 21.9332 20.8673 21.9332 20.6407ZM26.036 22.7501C25.7731 22.8569 25.51 22.9506 25.2575 22.961C24.8655 22.9793 24.4371 22.8203 24.204 22.6251C23.8434 22.323 23.5856 22.1537 23.4762 21.6225C23.4306 21.3959 23.4567 21.047 23.497 20.8465C23.5908 20.4141 23.4866 20.1381 23.1832 19.8855C22.9346 19.6798 22.6207 19.6251 22.2744 19.6251C22.1455 19.6251 22.027 19.5678 21.9384 19.5209C21.7939 19.4479 21.6754 19.2683 21.7887 19.047C21.8251 18.9766 22.001 18.8022 22.0426 18.7709C22.5114 18.5027 23.053 18.5913 23.5543 18.7918C24.0191 18.9818 24.3694 19.3307 24.8746 19.823C25.3915 20.4194 25.484 20.5861 25.7783 21.0313C26.01 21.3829 26.2223 21.7422 26.3668 22.1537C26.454 22.4089 26.3408 22.6198 26.036 22.7501Z" fill="#4D6BFE"/>
+</svg>

web/app/components/base/icons/assets/public/llm/gemini.svg

@@ -0,0 +1,105 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="40" height="40" fill="white"/>
+<mask id="mask0_3892_95663" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="6" y="6" width="28" height="29">
+<path d="M20 6C20.2936 6 20.5488 6.2005 20.6205 6.48556C20.8393 7.3566 21.1277 8.20866 21.4828 9.03356C22.4116 11.191 23.6854 13.0791 25.3032 14.6968C26.9218 16.3146 28.8095 17.5888 30.9664 18.5172C31.7941 18.8735 32.6436 19.16 33.5149 19.3795C33.6533 19.4143 33.7762 19.4942 33.8641 19.6067C33.9519 19.7192 33.9998 19.8578 34 20.0005C34 20.2941 33.7995 20.5492 33.5149 20.621C32.6437 20.8399 31.7915 21.1282 30.9664 21.4833C28.8095 22.4121 26.9209 23.6859 25.3032 25.3036C23.6854 26.9223 22.4116 28.8099 21.4828 30.9669C21.1278 31.7919 20.8394 32.6439 20.6205 33.5149C20.586 33.6534 20.5062 33.7764 20.3937 33.8644C20.2813 33.9524 20.1427 34.0003 20 34.0005C19.8572 34.0003 19.7186 33.9525 19.6062 33.8645C19.4937 33.7765 19.414 33.6535 19.3795 33.5149C19.1605 32.6439 18.872 31.7918 18.5167 30.9669C17.5884 28.8099 16.3151 26.9214 14.6964 25.3036C13.0782 23.6859 11.1906 22.4121 9.03309 21.4833C8.20814 21.1283 7.35608 20.8399 6.48509 20.621C6.34667 20.5864 6.22377 20.5065 6.13589 20.3941C6.04801 20.2817 6.00018 20.1432 6 20.0005C6.00024 19.8578 6.04808 19.7192 6.13594 19.6067C6.2238 19.4942 6.34667 19.4143 6.48509 19.3795C7.35612 19.1607 8.20819 18.8723 9.03309 18.5172C11.1906 17.5888 13.0786 16.3146 14.6964 14.6968C16.3141 13.0791 17.5884 11.191 18.5167 9.03356C18.8719 8.20862 19.1604 7.35656 19.3795 6.48556C19.4508 6.2005 19.7064 6 20 6Z" fill="black"/>
+<path d="M20 6C20.2936 6 20.5488 6.2005 20.6205 6.48556C20.8393 7.3566 21.1277 8.20866 21.4828 9.03356C22.4116 11.191 23.6854 13.0791 25.3032 14.6968C26.9218 16.3146 28.8095 17.5888 30.9664 18.5172C31.7941 18.8735 32.6436 19.16 33.5149 19.3795C33.6533 19.4143 33.7762 19.4942 33.8641 19.6067C33.9519 19.7192 33.9998 19.8578 34 20.0005C34 20.2941 33.7995 20.5492 33.5149 20.621C32.6437 20.8399 31.7915 21.1282 30.9664 21.4833C28.8095 22.4121 26.9209 23.6859 25.3032 25.3036C23.6854 26.9223 22.4116 28.8099 21.4828 30.9669C21.1278 31.7919 20.8394 32.6439 20.6205 33.5149C20.586 33.6534 20.5062 33.7764 20.3937 33.8644C20.2813 33.9524 20.1427 34.0003 20 34.0005C19.8572 34.0003 19.7186 33.9525 19.6062 33.8645C19.4937 33.7765 19.414 33.6535 19.3795 33.5149C19.1605 32.6439 18.872 31.7918 18.5167 30.9669C17.5884 28.8099 16.3151 26.9214 14.6964 25.3036C13.0782 23.6859 11.1906 22.4121 9.03309 21.4833C8.20814 21.1283 7.35608 20.8399 6.48509 20.621C6.34667 20.5864 6.22377 20.5065 6.13589 20.3941C6.04801 20.2817 6.00018 20.1432 6 20.0005C6.00024 19.8578 6.04808 19.7192 6.13594 19.6067C6.2238 19.4942 6.34667 19.4143 6.48509 19.3795C7.35612 19.1607 8.20819 18.8723 9.03309 18.5172C11.1906 17.5888 13.0786 16.3146 14.6964 14.6968C16.3141 13.0791 17.5884 11.191 18.5167 9.03356C18.8719 8.20862 19.1604 7.35656 19.3795 6.48556C19.4508 6.2005 19.7064 6 20 6Z" fill="url(#paint0_linear_3892_95663)"/>
+</mask>
+<g mask="url(#mask0_3892_95663)">
+<g filter="url(#filter0_f_3892_95663)">
+<path d="M3.47232 27.8921C6.70753 29.0411 10.426 26.8868 11.7778 23.0804C13.1296 19.274 11.6028 15.2569 8.36763 14.108C5.13242 12.959 1.41391 15.1133 0.06211 18.9197C-1.28969 22.7261 0.23711 26.7432 3.47232 27.8921Z" fill="#FFE432"/>
+</g>
+<g filter="url(#filter1_f_3892_95663)">
+<path d="M17.8359 15.341C22.2806 15.341 25.8838 11.6588 25.8838 7.11644C25.8838 2.57412 22.2806 -1.10815 17.8359 -1.10815C13.3912 -1.10815 9.78809 2.57412 9.78809 7.11644C9.78809 11.6588 13.3912 15.341 17.8359 15.341Z" fill="#FC413D"/>
+</g>
+<g filter="url(#filter2_f_3892_95663)">
+<path d="M14.7081 41.6431C19.3478 41.4163 22.8707 36.3599 22.5768 30.3493C22.283 24.3387 18.2836 19.65 13.644 19.8769C9.00433 20.1037 5.48139 25.1601 5.77525 31.1707C6.06911 37.1813 10.0685 41.87 14.7081 41.6431Z" fill="#00B95C"/>
+</g>
+<g filter="url(#filter3_f_3892_95663)">
+<path d="M14.7081 41.6431C19.3478 41.4163 22.8707 36.3599 22.5768 30.3493C22.283 24.3387 18.2836 19.65 13.644 19.8769C9.00433 20.1037 5.48139 25.1601 5.77525 31.1707C6.06911 37.1813 10.0685 41.87 14.7081 41.6431Z" fill="#00B95C"/>
+</g>
+<g filter="url(#filter4_f_3892_95663)">
+<path d="M19.355 38.0071C23.2447 35.6405 24.2857 30.2506 21.6803 25.9684C19.0748 21.6862 13.8095 20.1334 9.91983 22.5C6.03016 24.8666 4.98909 30.2565 7.59454 34.5387C10.2 38.8209 15.4653 40.3738 19.355 38.0071Z" fill="#00B95C"/>
+</g>
+<g filter="url(#filter5_f_3892_95663)">
+<path d="M35.0759 24.5504C39.4477 24.5504 42.9917 21.1377 42.9917 16.9278C42.9917 12.7179 39.4477 9.30518 35.0759 9.30518C30.7042 9.30518 27.1602 12.7179 27.1602 16.9278C27.1602 21.1377 30.7042 24.5504 35.0759 24.5504Z" fill="#3186FF"/>
+</g>
+<g filter="url(#filter6_f_3892_95663)">
+<path d="M0.362818 23.6667C4.3882 26.7279 10.2688 25.7676 13.4976 21.5219C16.7264 17.2762 16.0806 11.3528 12.0552 8.29156C8.02982 5.23037 2.14917 6.19062 -1.07959 10.4364C-4.30835 14.6821 -3.66256 20.6055 0.362818 23.6667Z" fill="#FBBC04"/>
+</g>
+<g filter="url(#filter7_f_3892_95663)">
+<path d="M20.9877 28.1903C25.7924 31.4936 32.1612 30.5732 35.2128 26.1346C38.2644 21.696 36.8432 15.4199 32.0385 12.1166C27.2338 8.81334 20.865 9.73372 17.8134 14.1723C14.7618 18.611 16.183 24.887 20.9877 28.1903Z" fill="#3186FF"/>
+</g>
+<g filter="url(#filter8_f_3892_95663)">
+<path d="M29.7231 4.99175C30.9455 6.65415 29.3748 9.88535 26.2149 12.2096C23.0549 14.5338 19.5026 15.0707 18.2801 13.4088C17.0576 11.7468 18.6284 8.51514 21.7883 6.19092C24.9482 3.86717 28.5006 3.32982 29.7231 4.99175Z" fill="#749BFF"/>
+</g>
+<g filter="url(#filter9_f_3892_95663)">
+<path d="M19.6891 12.9486C24.5759 8.41581 26.2531 2.27858 23.4354 -0.759249C20.6176 -3.79708 14.3718 -2.58516 9.485 1.94765C4.59823 6.48046 2.92099 12.6177 5.73879 15.6555C8.55658 18.6933 14.8024 17.4814 19.6891 12.9486Z" fill="#FC413D"/>
+</g>
+<g filter="url(#filter10_f_3892_95663)">
+<path d="M9.6712 29.23C12.5757 31.3088 15.9102 31.6247 17.1191 29.9356C18.328 28.2465 16.9535 25.1921 14.049 23.1133C11.1446 21.0345 7.81003 20.7186 6.60113 22.4077C5.39223 24.0968 6.76675 27.1512 9.6712 29.23Z" fill="#FFEE48"/>
+</g>
+</g>
+<defs>
+<filter id="filter0_f_3892_95663" x="-3.44095" y="10.7885" width="18.7217" height="20.4229" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="1.50514" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter1_f_3892_95663" x="-4.76352" y="-15.6598" width="45.1989" height="45.5524" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="7.2758" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter2_f_3892_95663" x="-6.61209" y="7.49899" width="41.5757" height="46.522" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="6.18495" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter3_f_3892_95663" x="-6.61209" y="7.49899" width="41.5757" height="46.522" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="6.18495" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter4_f_3892_95663" x="-6.21073" y="9.02316" width="41.6959" height="42.4608" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="6.18495" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter5_f_3892_95663" x="15.405" y="-2.44994" width="39.3423" height="38.7556" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="5.87756" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter6_f_3892_95663" x="-13.7886" y="-4.15284" width="39.9951" height="40.2639" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="5.32691" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter7_f_3892_95663" x="6.6925" y="0.620963" width="39.6414" height="39.065" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="4.75678" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter8_f_3892_95663" x="9.35225" y="-4.48661" width="29.2984" height="27.3739" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="4.25649" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter9_f_3892_95663" x="-2.81919" y="-9.62339" width="34.8122" height="34.143" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="3.59514" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<filter id="filter10_f_3892_95663" x="-2.73761" y="12.4221" width="29.1949" height="27.4994" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/>
+<feGaussianBlur stdDeviation="4.44986" result="effect1_foregroundBlur_3892_95663"/>
+</filter>
+<linearGradient id="paint0_linear_3892_95663" x1="13.9595" y1="24.7349" x2="28.5025" y2="12.4738" gradientUnits="userSpaceOnUse">
+<stop stop-color="#4893FC"/>
+<stop offset="0.27" stop-color="#4893FC"/>
+<stop offset="0.777" stop-color="#969DFF"/>
+<stop offset="1" stop-color="#BD99FE"/>
+</linearGradient>
+</defs>
+</svg>

web/app/components/base/icons/assets/public/llm/grok.svg

@@ -0,0 +1,11 @@
+<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="40" height="40" fill="white"/>
+<g clip-path="url(#clip0_3892_95659)">
+<path d="M15.745 24.54L26.715 16.35C27.254 15.95 28.022 16.106 28.279 16.73C29.628 20.018 29.025 23.971 26.341 26.685C23.658 29.399 19.924 29.995 16.511 28.639L12.783 30.384C18.13 34.081 24.623 33.166 28.681 29.06C31.9 25.805 32.897 21.368 31.965 17.367L31.973 17.376C30.622 11.498 32.305 9.149 35.755 4.345L36 4L31.46 8.59V8.576L15.743 24.544M13.48 26.531C9.643 22.824 10.305 17.085 13.58 13.776C16 11.327 19.968 10.328 23.432 11.797L27.152 10.06C26.482 9.57 25.622 9.043 24.637 8.673C20.182 6.819 14.848 7.742 11.227 11.401C7.744 14.924 6.648 20.341 8.53 24.962C9.935 28.416 7.631 30.86 5.31 33.326C4.49 34.2 3.666 35.074 3 36L13.478 26.534" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_3892_95659">
+<rect width="33" height="32" fill="white" transform="translate(3 4)"/>
+</clipPath>
+</defs>
+</svg>

web/app/components/base/icons/assets/public/llm/openai-small.svg

@@ -0,0 +1,17 @@
+<svg width="26" height="26" viewBox="0 0 26 26" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g clip-path="url(#clip0_3892_83671)">
+<path d="M1 13C1 9.27247 1 7.4087 1.60896 5.93853C2.42092 3.97831 3.97831 2.42092 5.93853 1.60896C7.4087 1 9.27247 1 13 1C16.7275 1 18.5913 1 20.0615 1.60896C22.0217 2.42092 23.5791 3.97831 24.391 5.93853C25 7.4087 25 9.27247 25 13C25 16.7275 25 18.5913 24.391 20.0615C23.5791 22.0217 22.0217 23.5791 20.0615 24.391C18.5913 25 16.7275 25 13 25C9.27247 25 7.4087 25 5.93853 24.391C3.97831 23.5791 2.42092 22.0217 1.60896 20.0615C1 18.5913 1 16.7275 1 13Z" fill="white"/>
+<rect width="24" height="24" transform="translate(1 1)" fill="url(#pattern0_3892_83671)"/>
+<rect width="24" height="24" transform="translate(1 1)" fill="white" fill-opacity="0.01"/>
+</g>
+<path d="M13 0.75C14.8603 0.75 16.2684 0.750313 17.3945 0.827148C18.5228 0.904144 19.3867 1.05876 20.1572 1.37793C22.1787 2.21525 23.7847 3.82133 24.6221 5.84277C24.9412 6.61333 25.0959 7.47723 25.1729 8.60547C25.2497 9.73161 25.25 11.1397 25.25 13C25.25 14.8603 25.2497 16.2684 25.1729 17.3945C25.0959 18.5228 24.9412 19.3867 24.6221 20.1572C23.7847 22.1787 22.1787 23.7847 20.1572 24.6221C19.3867 24.9412 18.5228 25.0959 17.3945 25.1729C16.2684 25.2497 14.8603 25.25 13 25.25C11.1397 25.25 9.73161 25.2497 8.60547 25.1729C7.47723 25.0959 6.61333 24.9412 5.84277 24.6221C3.82133 23.7847 2.21525 22.1787 1.37793 20.1572C1.05876 19.3867 0.904144 18.5228 0.827148 17.3945C0.750313 16.2684 0.75 14.8603 0.75 13C0.75 11.1397 0.750313 9.73161 0.827148 8.60547C0.904144 7.47723 1.05876 6.61333 1.37793 5.84277C2.21525 3.82133 3.82133 2.21525 5.84277 1.37793C6.61333 1.05876 7.47723 0.904144 8.60547 0.827148C9.73161 0.750313 11.1397 0.75 13 0.75Z" stroke="#101828" stroke-opacity="0.08" stroke-width="0.5"/>
+<defs>
+<pattern id="pattern0_3892_83671" patternContentUnits="objectBoundingBox" width="1" height="1">
+<use xlink:href="#image0_3892_83671" transform="scale(0.00625)"/>
+</pattern>
+<clipPath id="clip0_3892_83671">
+<path d="M1 13C1 9.27247 1 7.4087 1.60896 5.93853C2.42092 3.97831 3.97831 2.42092 5.93853 1.60896C7.4087 1 9.27247 1 13 1C16.7275 1 18.5913 1 20.0615 1.60896C22.0217 2.42092 23.5791 3.97831 24.391 5.93853C25 7.4087 25 9.27247 25 13C25 16.7275 25 18.5913 24.391 20.0615C23.5791 22.0217 22.0217 23.5791 20.0615 24.391C18.5913 25 16.7275 25 13 25C9.27247 25 7.4087 25 5.93853 24.391C3.97831 23.5791 2.42092 22.0217 1.60896 20.0615C1 18.5913 1 16.7275 1 13Z" fill="white"/>
+</clipPath>
+<image id="image0_3892_83671" width="160" height="160" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>
+</defs>
+</svg>

web/app/components/base/icons/src/public/llm/AnthropicShortLight.json

@@ -0,0 +1,36 @@
+{
+  "icon": {
+    "type": "element",
+    "isRootNode": true,
+    "name": "svg",
+    "attributes": {
+      "width": "40",
+      "height": "40",
+      "viewBox": "0 0 40 40",
+      "fill": "none",
+      "xmlns": "http://www.w3.org/2000/svg"
+    },
+    "children": [
+      {
+        "type": "element",
+        "name": "rect",
+        "attributes": {
+          "width": "40",
+          "height": "40",
+          "fill": "white"
+        },
+        "children": []
+      },
+      {
+        "type": "element",
+        "name": "path",
+        "attributes": {
+          "d": "M25.7926 10.1311H21.5089L29.3208 29.869H33.6045L25.7926 10.1311ZM13.4164 10.1311L5.60449 29.869H9.97273L11.5703 25.724H19.743L21.3405 29.869H25.7087L17.8969 10.1311H13.4164ZM12.9834 22.0583L15.6566 15.1217L18.3299 22.0583H12.9834Z",
+          "fill": "black"
+        },
+        "children": []
+      }
+    ]
+  },
+  "name": "AnthropicShortLight"
+}

web/app/components/base/icons/src/public/llm/AnthropicShortLight.tsx

@@ -0,0 +1,20 @@
+// GENERATE BY script
+// DON NOT EDIT IT MANUALLY
+
+import type { IconData } from '@/app/components/base/icons/IconBase'
+import * as React from 'react'
+import IconBase from '@/app/components/base/icons/IconBase'
+import data from './AnthropicShortLight.json'
+
+const Icon = (
+  {
+    ref,
+    ...props
+  }: React.SVGProps<SVGSVGElement> & {
+    ref?: React.RefObject<React.RefObject<HTMLOrSVGElement>>
+  },
+) => <IconBase {...props} ref={ref} data={data as IconData} />
+
+Icon.displayName = 'AnthropicShortLight'
+
+export default Icon

web/app/components/base/icons/src/public/llm/Deepseek.json

@@ -0,0 +1,36 @@
+{
+  "icon": {
+    "type": "element",
+    "isRootNode": true,
+    "name": "svg",
+    "attributes": {
+      "width": "40",
+      "height": "40",
+      "viewBox": "0 0 40 40",
+      "fill": "none",
+      "xmlns": "http://www.w3.org/2000/svg"
+    },
+    "children": [
+      {
+        "type": "element",
+        "name": "rect",
+        "attributes": {
+          "width": "40",
+          "height": "40",
+          "fill": "white"
+        },
+        "children": []
+      },
+      {
+        "type": "element",
+        "name": "path",
+        "attributes": {
+          "d": "M36.6676 11.2917C36.3316 11.1277 36.1871 11.4402 35.9906 11.599C35.9242 11.6511 35.8668 11.7188 35.8108 11.7787C35.3199 12.3048 34.747 12.6485 33.9996 12.6068C32.9046 12.5469 31.971 12.8907 31.1455 13.7293C30.9696 12.6954 30.3863 12.0782 29.4996 11.6824C29.0348 11.4766 28.5647 11.2709 28.2406 10.823C28.0127 10.5053 27.9515 10.1511 27.8368 9.80214C27.7652 9.59121 27.6923 9.37506 27.4502 9.33861C27.1871 9.29694 27.0843 9.51829 26.9814 9.70318C26.5674 10.4584 26.4084 11.2917 26.4228 12.1355C26.4592 14.0313 27.26 15.5417 28.8486 16.6173C29.0296 16.7397 29.0764 16.8646 29.0191 17.0443C28.9111 17.4141 28.7822 17.7735 28.6676 18.1433C28.596 18.3803 28.4879 18.4323 28.2354 18.3282C27.363 17.9637 26.609 17.4246 25.9436 16.7709C24.8135 15.6771 23.7914 14.4689 22.5166 13.5235C22.2171 13.3021 21.919 13.0964 21.609 12.9011C20.3082 11.6355 21.7796 10.5964 22.1194 10.474C22.4762 10.3464 22.2431 9.9037 21.092 9.90891C19.9423 9.91413 18.889 10.2995 17.5478 10.8126C17.3512 10.8907 17.1455 10.948 16.9332 10.9922C15.7158 10.7631 14.4515 10.711 13.1298 10.8594C10.6428 11.1381 8.65587 12.3152 7.19493 14.3255C5.44102 16.7397 5.02826 19.4845 5.53347 22.349C6.06473 25.3646 7.60249 27.8646 9.96707 29.8178C12.4176 31.8413 15.2406 32.8334 18.4606 32.6433C20.4163 32.5313 22.5947 32.2683 25.0504 30.1875C25.6702 30.4949 26.3199 30.6173 27.3994 30.711C28.2302 30.7891 29.0296 30.6694 29.6494 30.5417C30.6194 30.3361 30.5518 29.4375 30.2015 29.2709C27.3578 27.9454 27.9814 28.4845 27.4136 28.0495C28.859 26.3361 31.0374 24.5574 31.889 18.797C31.9554 18.3386 31.898 18.0522 31.889 17.6798C31.8838 17.4558 31.9346 17.3673 32.1923 17.3413C32.9046 17.2605 33.596 17.0651 34.2314 16.7137C36.0739 15.7058 36.816 14.0522 36.9918 12.0678C37.0179 11.7657 36.9866 11.4506 36.6676 11.2917ZM20.613 29.1485C17.8564 26.9793 16.5204 26.2657 15.9684 26.297C15.4527 26.3255 15.5452 26.9167 15.6584 27.3022C15.777 27.6823 15.9319 27.9454 16.1494 28.2787C16.2991 28.5001 16.402 28.8307 15.9996 29.0755C15.1116 29.6277 13.5687 28.8907 13.4958 28.8542C11.7001 27.797 10.1988 26.3985 9.14025 24.487C8.11941 22.6459 7.52566 20.6719 7.42801 18.5651C7.40197 18.0547 7.5517 17.875 8.05691 17.7839C8.72227 17.6615 9.40978 17.6355 10.0751 17.7318C12.8876 18.1433 15.2822 19.4037 17.2887 21.3959C18.4346 22.5339 19.3018 23.8907 20.195 25.2162C21.1442 26.6251 22.1663 27.9662 23.4671 29.0651C23.9254 29.4506 24.2926 29.7449 24.6428 29.961C23.5856 30.0782 21.8199 30.1042 20.613 29.1485ZM21.9332 20.6407C21.9332 20.4141 22.1142 20.2345 22.342 20.2345C22.3928 20.2345 22.4398 20.2449 22.4814 20.2605C22.5374 20.2813 22.5895 20.3126 22.6299 20.3594C22.7027 20.4298 22.7444 20.5339 22.7444 20.6407C22.7444 20.8673 22.5635 21.047 22.3368 21.047C22.109 21.047 21.9332 20.8673 21.9332 20.6407ZM26.036 22.7501C25.7731 22.8569 25.51 22.9506 25.2575 22.961C24.8655 22.9793 24.4371 22.8203 24.204 22.6251C23.8434 22.323 23.5856 22.1537 23.4762 21.6225C23.4306 21.3959 23.4567 21.047 23.497 20.8465C23.5908 20.4141 23.4866 20.1381 23.1832 19.8855C22.9346 19.6798 22.6207 19.6251 22.2744 19.6251C22.1455 19.6251 22.027 19.5678 21.9384 19.5209C21.7939 19.4479 21.6754 19.2683 21.7887 19.047C21.8251 18.9766 22.001 18.8022 22.0426 18.7709C22.5114 18.5027 23.053 18.5913 23.5543 18.7918C24.0191 18.9818 24.3694 19.3307 24.8746 19.823C25.3915 20.4194 25.484 20.5861 25.7783 21.0313C26.01 21.3829 26.2223 21.7422 26.3668 22.1537C26.454 22.4089 26.3408 22.6198 26.036 22.7501Z",
+          "fill": "#4D6BFE"
+        },
+        "children": []
+      }
+    ]
+  },
+  "name": "Deepseek"
+}