add command sql log args

Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Co-authored-by: yyh <92089059+lyzno1@users.noreply.github.com>

.github/labeler.yml

@@ -0,0 +1,3 @@
+web:
+  - changed-files:
+      - any-glob-to-any-file: 'web/**'

.github/workflows/labeler.yml

@@ -0,0 +1,14 @@
+name: "Pull Request Labeler"
+on:
+  pull_request_target:
+
+jobs:
+  labeler:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v6
+        with:
+          sync-labels: true

.github/workflows/style.yml

@@ -117,6 +117,11 @@ jobs:
       #     eslint-report: web/eslint_report.json
       #     github-token: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Web tsslint
+        if: steps.changed-files.outputs.any_changed == 'true'
+        working-directory: ./web
+        run: pnpm run lint:tss
+
       - name: Web type check
         if: steps.changed-files.outputs.any_changed == 'true'
         working-directory: ./web

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

@@ -134,6 +134,9 @@ jobs:
         with:
           anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
           github_token: ${{ secrets.GITHUB_TOKEN }}
+          # Allow github-actions bot to trigger this workflow via repository_dispatch
+          # See: https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          allowed_bots: 'github-actions[bot]'
           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).
@@ -285,6 +288,22 @@ jobs:
               - `${variable}` - Template literal
               - `<tag>content</tag>` - HTML tags
               - `_one`, `_other` - Pluralization suffixes (these are KEY suffixes, not values)
+
+              **CRITICAL: Variable names and tag names MUST stay in English - NEVER translate them**
+
+              ✅ CORRECT examples:
+              - English: "{{count}} items" → Japanese: "{{count}} 個のアイテム"
+              - English: "{{name}} updated" → Korean: "{{name}} 업데이트됨"
+              - English: "<email>{{email}}</email>" → Chinese: "<email>{{email}}</email>"
+              - English: "<CustomLink>Marketplace</CustomLink>" → Japanese: "<CustomLink>マーケットプレイス</CustomLink>"
+
+              ❌ WRONG examples (NEVER do this - will break the application):
+              - "{{count}}" → "{{カウント}}" ❌ (variable name translated to Japanese)
+              - "{{name}}" → "{{이름}}" ❌ (variable name translated to Korean)
+              - "{{email}}" → "{{邮箱}}" ❌ (variable name translated to Chinese)
+              - "<email>" → "<メール>" ❌ (tag name translated)
+              - "<CustomLink>" → "<自定义链接>" ❌ (component name translated)
+
             - Use appropriate language register (formal/informal) based on existing translations
             - Match existing translation style in each language
             - Technical terms: check existing conventions per language

.gitignore

@@ -209,7 +209,6 @@ api/.vscode
 .history
 
 .idea/
-web/migration/
 
 # pnpm
 /.pnpm-store

api/agent-notes/controllers/console/datasets/datasets_document.py.md

@@ -0,0 +1,52 @@
+## Purpose
+
+`api/controllers/console/datasets/datasets_document.py` contains the console (authenticated) APIs for managing dataset documents (list/create/update/delete, processing controls, estimates, etc.).
+
+## Storage model (uploaded files)
+
+- For local file uploads into a knowledge base, the binary is stored via `extensions.ext_storage.storage` under the key:
+  - `upload_files/<tenant_id>/<uuid>.<ext>`
+- File metadata is stored in the `upload_files` table (`UploadFile` model), keyed by `UploadFile.id`.
+- Dataset `Document` records reference the uploaded file via:
+  - `Document.data_source_info.upload_file_id`
+
+## Download endpoint
+
+- `GET /datasets/<dataset_id>/documents/<document_id>/download`
+
+  - Only supported when `Document.data_source_type == "upload_file"`.
+  - Performs dataset permission + tenant checks via `DocumentResource.get_document(...)`.
+  - Delegates `Document -> UploadFile` validation and signed URL generation to `DocumentService.get_document_download_url(...)`.
+  - Applies `cloud_edition_billing_rate_limit_check("knowledge")` to match other KB operations.
+  - Response body is **only**: `{ "url": "<signed-url>" }`.
+
+- `POST /datasets/<dataset_id>/documents/download-zip`
+
+  - Accepts `{ "document_ids": ["..."] }` (upload-file only).
+  - Returns `application/zip` as a single attachment download.
+  - Rationale: browsers often block multiple automatic downloads; a ZIP avoids that limitation.
+  - Applies `cloud_edition_billing_rate_limit_check("knowledge")`.
+  - Delegates dataset permission checks, document/upload-file validation, and download-name generation to
+    `DocumentService.prepare_document_batch_download_zip(...)` before streaming the ZIP.
+
+## Verification plan
+
+- Upload a document from a local file into a dataset.
+- Call the download endpoint and confirm it returns a signed URL.
+- Open the URL and confirm:
+  - Response headers force download (`Content-Disposition`), and
+  - Downloaded bytes match the uploaded file.
+- Select multiple uploaded-file documents and download as ZIP; confirm all selected files exist in the archive.
+
+## Shared helper
+
+- `DocumentService.get_document_download_url(document)` resolves the `UploadFile` and signs a download URL.
+- `DocumentService.prepare_document_batch_download_zip(...)` performs dataset permission checks, batches
+  document + upload file lookups, preserves request order, and generates the client-visible ZIP filename.
+- Internal helpers now live in `DocumentService` (`_get_upload_file_id_for_upload_file_document(...)`,
+  `_get_upload_file_for_upload_file_document(...)`, `_get_upload_files_by_document_id_for_zip_download(...)`).
+- ZIP packing is handled by `FileService.build_upload_files_zip_tempfile(...)`, which also:
+  - sanitizes entry names to avoid path traversal, and
+  - deduplicates names while preserving extensions (e.g., `doc.txt` → `doc (1).txt`).
+    Streaming the response and deferring cleanup is handled by the route via `send_file(path, ...)` + `ExitStack` +
+    `response.call_on_close(...)` (the file is deleted when the response is closed).

api/agent-notes/services/dataset_service.py.md

@@ -0,0 +1,18 @@
+## Purpose
+
+`api/services/dataset_service.py` hosts dataset/document service logic used by console and API controllers.
+
+## Batch document operations
+
+- Batch document workflows should avoid N+1 database queries by using set-based lookups.
+- Tenant checks must be enforced consistently across dataset/document operations.
+- `DocumentService.get_documents_by_ids(...)` fetches documents for a dataset using `id.in_(...)`.
+- `FileService.get_upload_files_by_ids(...)` performs tenant-scoped batch lookup for `UploadFile` (dedupes ids with `set(...)`).
+- `DocumentService.get_document_download_url(...)` and `prepare_document_batch_download_zip(...)` handle
+  dataset/document permission checks plus `Document -> UploadFile` validation for download endpoints.
+
+## Verification plan
+
+- Exercise document list and download endpoints that use the service helpers.
+- Confirm batch download uses constant query count for documents + upload files.
+- Request a ZIP with a missing document id and confirm a 404 is returned.

api/agent-notes/services/file_service.py.md

@@ -0,0 +1,35 @@
+## Purpose
+
+`api/services/file_service.py` owns business logic around `UploadFile` objects: upload validation, storage persistence,
+previews/generators, and deletion.
+
+## Key invariants
+
+- All storage I/O goes through `extensions.ext_storage.storage`.
+- Uploaded file keys follow: `upload_files/<tenant_id>/<uuid>.<ext>`.
+- Upload validation is enforced in `FileService.upload_file(...)` (blocked extensions, size limits, dataset-only types).
+
+## Batch lookup helpers
+
+- `FileService.get_upload_files_by_ids(tenant_id, upload_file_ids)` is the canonical tenant-scoped batch loader for
+  `UploadFile`.
+
+## Dataset document download helpers
+
+The dataset document download/ZIP endpoints now delegate “Document → UploadFile” validation and permission checks to
+`DocumentService` (`api/services/dataset_service.py`). `FileService` stays focused on generic `UploadFile` operations
+(uploading, previews, deletion), plus generic ZIP serving.
+
+### ZIP serving
+
+- `FileService.build_upload_files_zip_tempfile(...)` builds a ZIP from `UploadFile` objects and yields a seeked
+  tempfile **path** so callers can stream it (e.g., `send_file(path, ...)`) without hitting "read of closed file"
+  issues from file-handle lifecycle during streamed responses.
+- Flask `send_file(...)` and the `ExitStack`/`call_on_close(...)` cleanup pattern are handled in the route layer.
+
+## Verification plan
+
+- Unit: `api/tests/unit_tests/controllers/console/datasets/test_datasets_document_download.py`
+  - Verify signed URL generation for upload-file documents and ZIP download behavior for multiple documents.
+- Unit: `api/tests/unit_tests/services/test_file_service_zip_and_lookup.py`
+  - Verify ZIP packing produces a valid, openable archive and preserves file content.

api/agent-notes/tests/unit_tests/controllers/console/datasets/test_datasets_document_download.py.md

@@ -0,0 +1,28 @@
+## Purpose
+
+Unit tests for the console dataset document download endpoint:
+
+- `GET /datasets/<dataset_id>/documents/<document_id>/download`
+
+## Testing approach
+
+- Uses `Flask.test_request_context()` and calls the `Resource.get(...)` method directly.
+- Monkeypatches console decorators (`login_required`, `setup_required`, rate limit) to no-ops to keep the test focused.
+- Mocks:
+  - `DatasetService.get_dataset` / `check_dataset_permission`
+  - `DocumentService.get_document` for single-file download tests
+  - `DocumentService.get_documents_by_ids` + `FileService.get_upload_files_by_ids` for ZIP download tests
+  - `FileService.get_upload_files_by_ids` for `UploadFile` lookups in single-file tests
+  - `services.dataset_service.file_helpers.get_signed_file_url` to return a deterministic URL
+- Document mocks include `id` fields so batch lookups can map documents by id.
+
+## Covered cases
+
+- Success returns `{ "url": "<signed>" }` for upload-file documents.
+- 404 when document is not `upload_file`.
+- 404 when `upload_file_id` is missing.
+- 404 when referenced `UploadFile` row does not exist.
+- 403 when document tenant does not match current tenant.
+- Batch ZIP download returns `application/zip` for upload-file documents.
+- Batch ZIP download rejects non-upload-file documents.
+- Batch ZIP download uses a random `.zip` attachment name (`download_name`), so tests only assert the suffix.

api/agent-notes/tests/unit_tests/services/test_file_service_zip_and_lookup.py.md

@@ -0,0 +1,18 @@
+## Purpose
+
+Unit tests for `api/services/file_service.py` helper methods that are not covered by higher-level controller tests.
+
+## What’s covered
+
+- `FileService.build_upload_files_zip_tempfile(...)`
+  - ZIP entry name sanitization (no directory components / traversal)
+  - name deduplication while preserving extensions
+  - writing streamed bytes from `storage.load(...)` into ZIP entries
+  - yields a tempfile path so callers can open/stream the ZIP without holding a live file handle
+- `FileService.get_upload_files_by_ids(...)`
+  - returns `{}` for empty id lists
+  - returns an id-keyed mapping for non-empty lists
+
+## Notes
+
+- These tests intentionally stub `storage.load` and `db.session.scalars(...).all()` to avoid needing a real DB/storage.

api/commands.py

@@ -4,13 +4,15 @@ import json
 import logging
 import secrets
 import time
+from collections.abc import Iterator
+from contextlib import contextmanager
 from typing import Any
 
 import click
 import sqlalchemy as sa
 from flask import current_app
 from pydantic import TypeAdapter
-from sqlalchemy import select
+from sqlalchemy import event, select
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import sessionmaker
 
@@ -55,6 +57,28 @@ from tasks.remove_app_and_related_data_task import delete_draft_variables_batch
 logger = logging.getLogger(__name__)
 
 
+@contextmanager
+def _log_slow_queries(engine: sa.engine.Engine, threshold_ms: float) -> Iterator[None]:
+    def _before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+        context._query_start_time = time.perf_counter()
+
+    def _after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+        start_time = getattr(context, "_query_start_time", None)
+        if start_time is None:
+            return
+        elapsed_ms = (time.perf_counter() - start_time) * 1000
+        if elapsed_ms >= threshold_ms:
+            logger.warning("Slow SQL query (%.2fms): %s", elapsed_ms, statement)
+
+    event.listen(engine, "before_cursor_execute", _before_cursor_execute)
+    event.listen(engine, "after_cursor_execute", _after_cursor_execute)
+    try:
+        yield
+    finally:
+        event.remove(engine, "before_cursor_execute", _before_cursor_execute)
+        event.remove(engine, "after_cursor_execute", _after_cursor_execute)
+
+
 @click.command("reset-password", help="Reset the account password.")
 @click.option("--email", prompt=True, help="Account email to reset password for")
 @click.option("--new-password", prompt=True, help="New password")
@@ -950,6 +974,356 @@ def clean_workflow_runs(
     )
 
 
+@click.command(
+    "archive-workflow-runs",
+    help="Archive workflow runs for paid plan tenants to S3-compatible storage.",
+)
+@click.option("--tenant-ids", default=None, help="Optional comma-separated tenant IDs for grayscale rollout.")
+@click.option("--before-days", default=90, show_default=True, help="Archive runs older than N days.")
+@click.option(
+    "--from-days-ago",
+    default=None,
+    type=click.IntRange(min=0),
+    help="Lower bound in days ago (older). Must be paired with --to-days-ago.",
+)
+@click.option(
+    "--to-days-ago",
+    default=None,
+    type=click.IntRange(min=0),
+    help="Upper bound in days ago (newer). Must be paired with --from-days-ago.",
+)
+@click.option(
+    "--start-from",
+    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
+    default=None,
+    help="Archive runs created at or after this timestamp (UTC if no timezone).",
+)
+@click.option(
+    "--end-before",
+    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
+    default=None,
+    help="Archive runs created before this timestamp (UTC if no timezone).",
+)
+@click.option("--batch-size", default=100, show_default=True, help="Batch size for processing.")
+@click.option("--workers", default=1, show_default=True, type=int, help="Concurrent workflow runs to archive.")
+@click.option("--limit", default=None, type=int, help="Maximum number of runs to archive.")
+@click.option("--dry-run", is_flag=True, help="Preview without archiving.")
+@click.option("--delete-after-archive", is_flag=True, help="Delete runs and related data after archiving.")
+@click.option(
+    "--slow-ms",
+    default=1000,
+    show_default=True,
+    type=int,
+    help="Log SQL queries slower than this threshold (ms).",
+)
+def archive_workflow_runs(
+    tenant_ids: str | None,
+    before_days: int,
+    from_days_ago: int | None,
+    to_days_ago: int | None,
+    start_from: datetime.datetime | None,
+    end_before: datetime.datetime | None,
+    batch_size: int,
+    workers: int,
+    limit: int | None,
+    dry_run: bool,
+    delete_after_archive: bool,
+    slow_ms: int,
+):
+    """
+    Archive workflow runs for paid plan tenants older than the specified days.
+
+    This command archives the following tables to storage:
+    - workflow_node_executions
+    - workflow_node_execution_offload
+    - workflow_pauses
+    - workflow_pause_reasons
+    - workflow_trigger_logs
+
+    The workflow_runs and workflow_app_logs tables are preserved for UI listing.
+    """
+    from services.retention.workflow_run.archive_paid_plan_workflow_run import WorkflowRunArchiver
+
+    run_started_at = datetime.datetime.now(datetime.UTC)
+    click.echo(
+        click.style(
+            f"Starting workflow run archiving at {run_started_at.isoformat()}.",
+            fg="white",
+        )
+    )
+
+    if (start_from is None) ^ (end_before is None):
+        click.echo(click.style("start-from and end-before must be provided together.", fg="red"))
+        return
+
+    if (from_days_ago is None) ^ (to_days_ago is None):
+        click.echo(click.style("from-days-ago and to-days-ago must be provided together.", fg="red"))
+        return
+
+    if from_days_ago is not None and to_days_ago is not None:
+        if start_from or end_before:
+            click.echo(click.style("Choose either day offsets or explicit dates, not both.", fg="red"))
+            return
+        if from_days_ago <= to_days_ago:
+            click.echo(click.style("from-days-ago must be greater than to-days-ago.", fg="red"))
+            return
+        now = datetime.datetime.now()
+        start_from = now - datetime.timedelta(days=from_days_ago)
+        end_before = now - datetime.timedelta(days=to_days_ago)
+        before_days = 0
+
+    if start_from and end_before and start_from >= end_before:
+        click.echo(click.style("start-from must be earlier than end-before.", fg="red"))
+        return
+    if workers < 1:
+        click.echo(click.style("workers must be at least 1.", fg="red"))
+        return
+
+    archiver = WorkflowRunArchiver(
+        days=before_days,
+        batch_size=batch_size,
+        start_from=start_from,
+        end_before=end_before,
+        workers=workers,
+        tenant_ids=[tid.strip() for tid in tenant_ids.split(",")] if tenant_ids else None,
+        limit=limit,
+        dry_run=dry_run,
+        delete_after_archive=delete_after_archive,
+    )
+    logger.info("Enable slow query logging for archive-workflow-runs (>=%sms).", slow_ms)
+    with _log_slow_queries(db.engine, slow_ms):
+        summary = archiver.run()
+    click.echo(
+        click.style(
+            f"Summary: processed={summary.total_runs_processed}, archived={summary.runs_archived}, "
+            f"skipped={summary.runs_skipped}, failed={summary.runs_failed}, "
+            f"time={summary.total_elapsed_time:.2f}s",
+            fg="cyan",
+        )
+    )
+
+    run_finished_at = datetime.datetime.now(datetime.UTC)
+    elapsed = run_finished_at - run_started_at
+    click.echo(
+        click.style(
+            f"Workflow run archiving completed. start={run_started_at.isoformat()} "
+            f"end={run_finished_at.isoformat()} duration={elapsed}",
+            fg="green",
+        )
+    )
+
+
+@click.command(
+    "restore-workflow-runs",
+    help="Restore archived workflow runs from S3-compatible storage.",
+)
+@click.option(
+    "--tenant-ids",
+    required=False,
+    help="Tenant IDs (comma-separated).",
+)
+@click.option("--run-id", required=False, help="Workflow run ID to restore.")
+@click.option(
+    "--start-from",
+    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
+    default=None,
+    help="Optional lower bound (inclusive) for created_at; must be paired with --end-before.",
+)
+@click.option(
+    "--end-before",
+    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
+    default=None,
+    help="Optional upper bound (exclusive) for created_at; must be paired with --start-from.",
+)
+@click.option("--workers", default=1, show_default=True, type=int, help="Concurrent workflow runs to restore.")
+@click.option("--limit", type=int, default=100, show_default=True, help="Maximum number of runs to restore.")
+@click.option("--dry-run", is_flag=True, help="Preview without restoring.")
+def restore_workflow_runs(
+    tenant_ids: str | None,
+    run_id: str | None,
+    start_from: datetime.datetime | None,
+    end_before: datetime.datetime | None,
+    workers: int,
+    limit: int,
+    dry_run: bool,
+):
+    """
+    Restore an archived workflow run from storage to the database.
+
+    This restores the following tables:
+    - workflow_node_executions
+    - workflow_node_execution_offload
+    - workflow_pauses
+    - workflow_pause_reasons
+    - workflow_trigger_logs
+    """
+    from services.retention.workflow_run.restore_archived_workflow_run import WorkflowRunRestore
+
+    parsed_tenant_ids = None
+    if tenant_ids:
+        parsed_tenant_ids = [tid.strip() for tid in tenant_ids.split(",") if tid.strip()]
+        if not parsed_tenant_ids:
+            raise click.BadParameter("tenant-ids must not be empty")
+
+    if (start_from is None) ^ (end_before is None):
+        raise click.UsageError("--start-from and --end-before must be provided together.")
+    if run_id is None and (start_from is None or end_before is None):
+        raise click.UsageError("--start-from and --end-before are required for batch restore.")
+    if workers < 1:
+        raise click.BadParameter("workers must be at least 1")
+
+    start_time = datetime.datetime.now(datetime.UTC)
+    click.echo(
+        click.style(
+            f"Starting restore of workflow run {run_id} at {start_time.isoformat()}.",
+            fg="white",
+        )
+    )
+
+    restorer = WorkflowRunRestore(dry_run=dry_run, workers=workers)
+    if run_id:
+        results = [restorer.restore_by_run_id(run_id)]
+    else:
+        assert start_from is not None
+        assert end_before is not None
+        results = restorer.restore_batch(
+            parsed_tenant_ids,
+            start_date=start_from,
+            end_date=end_before,
+            limit=limit,
+        )
+
+    end_time = datetime.datetime.now(datetime.UTC)
+    elapsed = end_time - start_time
+
+    successes = sum(1 for result in results if result.success)
+    failures = len(results) - successes
+
+    if failures == 0:
+        click.echo(
+            click.style(
+                f"Restore completed successfully. success={successes} duration={elapsed}",
+                fg="green",
+            )
+        )
+    else:
+        click.echo(
+            click.style(
+                f"Restore completed with failures. success={successes} failed={failures} duration={elapsed}",
+                fg="red",
+            )
+        )
+
+
+@click.command(
+    "delete-archived-workflow-runs",
+    help="Delete archived workflow runs from the database.",
+)
+@click.option(
+    "--tenant-ids",
+    required=False,
+    help="Tenant IDs (comma-separated).",
+)
+@click.option("--run-id", required=False, help="Workflow run ID to delete.")
+@click.option(
+    "--start-from",
+    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
+    default=None,
+    help="Optional lower bound (inclusive) for created_at; must be paired with --end-before.",
+)
+@click.option(
+    "--end-before",
+    type=click.DateTime(formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"]),
+    default=None,
+    help="Optional upper bound (exclusive) for created_at; must be paired with --start-from.",
+)
+@click.option("--limit", type=int, default=100, show_default=True, help="Maximum number of runs to delete.")
+@click.option("--dry-run", is_flag=True, help="Preview without deleting.")
+def delete_archived_workflow_runs(
+    tenant_ids: str | None,
+    run_id: str | None,
+    start_from: datetime.datetime | None,
+    end_before: datetime.datetime | None,
+    limit: int,
+    dry_run: bool,
+):
+    """
+    Delete archived workflow runs from the database.
+    """
+    from services.retention.workflow_run.delete_archived_workflow_run import ArchivedWorkflowRunDeletion
+
+    parsed_tenant_ids = None
+    if tenant_ids:
+        parsed_tenant_ids = [tid.strip() for tid in tenant_ids.split(",") if tid.strip()]
+        if not parsed_tenant_ids:
+            raise click.BadParameter("tenant-ids must not be empty")
+
+    if (start_from is None) ^ (end_before is None):
+        raise click.UsageError("--start-from and --end-before must be provided together.")
+    if run_id is None and (start_from is None or end_before is None):
+        raise click.UsageError("--start-from and --end-before are required for batch delete.")
+
+    start_time = datetime.datetime.now(datetime.UTC)
+    target_desc = f"workflow run {run_id}" if run_id else "workflow runs"
+    click.echo(
+        click.style(
+            f"Starting delete of {target_desc} at {start_time.isoformat()}.",
+            fg="white",
+        )
+    )
+
+    deleter = ArchivedWorkflowRunDeletion(dry_run=dry_run)
+    if run_id:
+        results = [deleter.delete_by_run_id(run_id)]
+    else:
+        assert start_from is not None
+        assert end_before is not None
+        results = deleter.delete_batch(
+            parsed_tenant_ids,
+            start_date=start_from,
+            end_date=end_before,
+            limit=limit,
+        )
+
+    for result in results:
+        if result.success:
+            click.echo(
+                click.style(
+                    f"{'[DRY RUN] Would delete' if dry_run else 'Deleted'} "
+                    f"workflow run {result.run_id} (tenant={result.tenant_id})",
+                    fg="green",
+                )
+            )
+        else:
+            click.echo(
+                click.style(
+                    f"Failed to delete workflow run {result.run_id}: {result.error}",
+                    fg="red",
+                )
+            )
+
+    end_time = datetime.datetime.now(datetime.UTC)
+    elapsed = end_time - start_time
+
+    successes = sum(1 for result in results if result.success)
+    failures = len(results) - successes
+
+    if failures == 0:
+        click.echo(
+            click.style(
+                f"Delete completed successfully. success={successes} duration={elapsed}",
+                fg="green",
+            )
+        )
+    else:
+        click.echo(
+            click.style(
+                f"Delete completed with failures. success={successes} failed={failures} duration={elapsed}",
+                fg="red",
+            )
+        )
+
+
 @click.option("-f", "--force", is_flag=True, help="Skip user confirmation and force the command to execute.")
 @click.command("clear-orphaned-file-records", help="Clear orphaned file records.")
 def clear_orphaned_file_records(force: bool):

api/controllers/console/app/app.py

@@ -1,4 +1,3 @@
-import re
 import uuid
 from datetime import datetime
 from typing import Any, Literal, TypeAlias
@@ -68,48 +67,6 @@ class AppListQuery(BaseModel):
             raise ValueError("Invalid UUID format in tag_ids.") from exc
 
 
-# XSS prevention: patterns that could lead to XSS attacks
-# Includes: script tags, iframe tags, javascript: protocol, SVG with onload, etc.
-_XSS_PATTERNS = [
-    r"<script[^>]*>.*?</script>",  # Script tags
-    r"<iframe\b[^>]*?(?:/>|>.*?</iframe>)",  # Iframe tags (including self-closing)
-    r"javascript:",  # JavaScript protocol
-    r"<svg[^>]*?\s+onload\s*=[^>]*>",  # SVG with onload handler (attribute-aware, flexible whitespace)
-    r"<.*?on\s*\w+\s*=",  # Event handlers like onclick, onerror, etc.
-    r"<object\b[^>]*(?:\s*/>|>.*?</object\s*>)",  # Object tags (opening tag)
-    r"<embed[^>]*>",  # Embed tags (self-closing)
-    r"<link[^>]*>",  # Link tags with javascript
-]
-
-
-def _validate_xss_safe(value: str | None, field_name: str = "Field") -> str | None:
-    """
-    Validate that a string value doesn't contain potential XSS payloads.
-
-    Args:
-        value: The string value to validate
-        field_name: Name of the field for error messages
-
-    Returns:
-        The original value if safe
-
-    Raises:
-        ValueError: If the value contains XSS patterns
-    """
-    if value is None:
-        return None
-
-    value_lower = value.lower()
-    for pattern in _XSS_PATTERNS:
-        if re.search(pattern, value_lower, re.DOTALL | re.IGNORECASE):
-            raise ValueError(
-                f"{field_name} contains invalid characters or patterns. "
-                "HTML tags, JavaScript, and other potentially dangerous content are not allowed."
-            )
-
-    return value
-
-
 class CreateAppPayload(BaseModel):
     name: str = Field(..., min_length=1, description="App name")
     description: str | None = Field(default=None, description="App description (max 400 chars)", max_length=400)
@@ -118,11 +75,6 @@ class CreateAppPayload(BaseModel):
     icon: str | None = Field(default=None, description="Icon")
     icon_background: str | None = Field(default=None, description="Icon background color")
 
-    @field_validator("name", "description", mode="before")
-    @classmethod
-    def validate_xss_safe(cls, value: str | None, info) -> str | None:
-        return _validate_xss_safe(value, info.field_name)
-
 
 class UpdateAppPayload(BaseModel):
     name: str = Field(..., min_length=1, description="App name")
@@ -133,11 +85,6 @@ class UpdateAppPayload(BaseModel):
     use_icon_as_answer_icon: bool | None = Field(default=None, description="Use icon as answer icon")
     max_active_requests: int | None = Field(default=None, description="Maximum active requests")
 
-    @field_validator("name", "description", mode="before")
-    @classmethod
-    def validate_xss_safe(cls, value: str | None, info) -> str | None:
-        return _validate_xss_safe(value, info.field_name)
-
 
 class CopyAppPayload(BaseModel):
     name: str | None = Field(default=None, description="Name for the copied app")
@@ -146,11 +93,6 @@ class CopyAppPayload(BaseModel):
     icon: str | None = Field(default=None, description="Icon")
     icon_background: str | None = Field(default=None, description="Icon background color")
 
-    @field_validator("name", "description", mode="before")
-    @classmethod
-    def validate_xss_safe(cls, value: str | None, info) -> str | None:
-        return _validate_xss_safe(value, info.field_name)
-
 
 class AppExportQuery(BaseModel):
     include_secret: bool = Field(default=False, description="Include secrets in export")

api/controllers/console/app/generator.py

@@ -55,35 +55,6 @@ class InstructionTemplatePayload(BaseModel):
     type: str = Field(..., description="Instruction template type")
 
 
-class ContextGeneratePayload(BaseModel):
-    """Payload for generating extractor code node."""
-
-    workflow_id: str = Field(..., description="Workflow ID")
-    node_id: str = Field(..., description="Current tool/llm node ID")
-    parameter_name: str = Field(..., description="Parameter name to generate code for")
-    language: str = Field(default="python3", description="Code language (python3/javascript)")
-    prompt_messages: list[dict[str, Any]] = Field(
-        ..., description="Multi-turn conversation history, last message is the current instruction"
-    )
-    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
-
-
-class SuggestedQuestionsPayload(BaseModel):
-    """Payload for generating suggested questions."""
-
-    workflow_id: str = Field(..., description="Workflow ID")
-    node_id: str = Field(..., description="Current tool/llm node ID")
-    parameter_name: str = Field(..., description="Parameter name")
-    language: str = Field(
-        default="English", description="Language for generated questions (e.g. English, Chinese, Japanese)"
-    )
-    model_config_data: dict[str, Any] | None = Field(
-        default=None,
-        alias="model_config",
-        description="Model configuration (optional, uses system default if not provided)",
-    )
-
-
 def reg(cls: type[BaseModel]):
     console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
 
@@ -93,8 +64,6 @@ reg(RuleCodeGeneratePayload)
 reg(RuleStructuredOutputPayload)
 reg(InstructionGeneratePayload)
 reg(InstructionTemplatePayload)
-reg(ContextGeneratePayload)
-reg(SuggestedQuestionsPayload)
 
 
 @console_ns.route("/rule-generate")
@@ -309,74 +278,3 @@ class InstructionGenerationTemplateApi(Resource):
                 return {"data": INSTRUCTION_GENERATE_TEMPLATE_CODE}
             case _:
                 raise ValueError(f"Invalid type: {args.type}")
-
-
-@console_ns.route("/context-generate")
-class ContextGenerateApi(Resource):
-    @console_ns.doc("generate_with_context")
-    @console_ns.doc(description="Generate with multi-turn conversation context")
-    @console_ns.expect(console_ns.models[ContextGeneratePayload.__name__])
-    @console_ns.response(200, "Content generated successfully")
-    @console_ns.response(400, "Invalid request parameters or workflow not found")
-    @console_ns.response(402, "Provider quota exceeded")
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def post(self):
-        from core.llm_generator.utils import deserialize_prompt_messages
-
-        args = ContextGeneratePayload.model_validate(console_ns.payload)
-        _, current_tenant_id = current_account_with_tenant()
-
-        prompt_messages = deserialize_prompt_messages(args.prompt_messages)
-
-        try:
-            return LLMGenerator.generate_with_context(
-                tenant_id=current_tenant_id,
-                workflow_id=args.workflow_id,
-                node_id=args.node_id,
-                parameter_name=args.parameter_name,
-                language=args.language,
-                prompt_messages=prompt_messages,
-                model_config=args.model_config_data,
-            )
-        except ProviderTokenNotInitError as ex:
-            raise ProviderNotInitializeError(ex.description)
-        except QuotaExceededError:
-            raise ProviderQuotaExceededError()
-        except ModelCurrentlyNotSupportError:
-            raise ProviderModelCurrentlyNotSupportError()
-        except InvokeError as e:
-            raise CompletionRequestError(e.description)
-
-
-@console_ns.route("/context-generate/suggested-questions")
-class SuggestedQuestionsApi(Resource):
-    @console_ns.doc("generate_suggested_questions")
-    @console_ns.doc(description="Generate suggested questions for context generation")
-    @console_ns.expect(console_ns.models[SuggestedQuestionsPayload.__name__])
-    @console_ns.response(200, "Questions generated successfully")
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def post(self):
-        args = SuggestedQuestionsPayload.model_validate(console_ns.payload)
-        _, current_tenant_id = current_account_with_tenant()
-
-        try:
-            return LLMGenerator.generate_suggested_questions(
-                tenant_id=current_tenant_id,
-                workflow_id=args.workflow_id,
-                node_id=args.node_id,
-                parameter_name=args.parameter_name,
-                language=args.language,
-                model_config=args.model_config_data,
-            )
-        except ProviderTokenNotInitError as ex:
-            raise ProviderNotInitializeError(ex.description)
-        except QuotaExceededError:
-            raise ProviderQuotaExceededError()
-        except ModelCurrentlyNotSupportError:
-            raise ProviderModelCurrentlyNotSupportError()
-        except InvokeError as e:
-            raise CompletionRequestError(e.description)

api/controllers/console/app/workflow.py

@@ -46,8 +46,6 @@ from models.workflow import Workflow
 from services.app_generate_service import AppGenerateService
 from services.errors.app import WorkflowHashNotEqualError
 from services.errors.llm import InvokeRateLimitError
-from services.workflow.entities import MentionGraphRequest, MentionParameterSchema
-from services.workflow.mention_graph_service import MentionGraphService
 from services.workflow_service import DraftWorkflowDeletionError, WorkflowInUseError, WorkflowService
 
 logger = logging.getLogger(__name__)
@@ -190,15 +188,6 @@ class DraftWorkflowTriggerRunAllPayload(BaseModel):
     node_ids: list[str]
 
 
-class MentionGraphPayload(BaseModel):
-    """Request payload for generating mention graph."""
-
-    parent_node_id: str = Field(description="ID of the parent node that uses the extracted value")
-    parameter_key: str = Field(description="Key of the parameter being extracted")
-    context_source: list[str] = Field(description="Variable selector for the context source")
-    parameter_schema: dict[str, Any] = Field(description="Schema of the parameter to extract")
-
-
 def reg(cls: type[BaseModel]):
     console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
 
@@ -216,7 +205,6 @@ reg(WorkflowListQuery)
 reg(WorkflowUpdatePayload)
 reg(DraftWorkflowTriggerRunPayload)
 reg(DraftWorkflowTriggerRunAllPayload)
-reg(MentionGraphPayload)
 
 
 # TODO(QuantumGhost): Refactor existing node run API to handle file parameter parsing
@@ -1178,54 +1166,3 @@ class DraftWorkflowTriggerRunAllApi(Resource):
                     "status": "error",
                 }
             ), 400
-
-
-@console_ns.route("/apps/<uuid:app_id>/workflows/draft/mention-graph")
-class MentionGraphApi(Resource):
-    """
-    API for generating Mention LLM node graph structures.
-
-    This endpoint creates a complete graph structure containing an LLM node
-    configured to extract values from list[PromptMessage] variables.
-    """
-
-    @console_ns.doc("generate_mention_graph")
-    @console_ns.doc(description="Generate a Mention LLM node graph structure")
-    @console_ns.doc(params={"app_id": "Application ID"})
-    @console_ns.expect(console_ns.models[MentionGraphPayload.__name__])
-    @console_ns.response(200, "Mention graph generated successfully")
-    @console_ns.response(400, "Invalid request parameters")
-    @console_ns.response(403, "Permission denied")
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
-    @edit_permission_required
-    def post(self, app_model: App):
-        """
-        Generate a Mention LLM node graph structure.
-
-        Returns a complete graph structure containing a single LLM node
-        configured for extracting values from list[PromptMessage] context.
-        """
-
-        payload = MentionGraphPayload.model_validate(console_ns.payload or {})
-
-        parameter_schema = MentionParameterSchema(
-            name=payload.parameter_schema.get("name", payload.parameter_key),
-            type=payload.parameter_schema.get("type", "string"),
-            description=payload.parameter_schema.get("description", ""),
-        )
-
-        request = MentionGraphRequest(
-            parent_node_id=payload.parent_node_id,
-            parameter_key=payload.parameter_key,
-            context_source=payload.context_source,
-            parameter_schema=parameter_schema,
-        )
-
-        with Session(db.engine) as session:
-            service = MentionGraphService(session)
-            response = service.generate_mention_graph(tenant_id=app_model.tenant_id, request=request)
-
-        return response.model_dump()

api/controllers/console/app/workflow_app_log.py

@@ -11,7 +11,10 @@ from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
 from core.workflow.enums import WorkflowExecutionStatus
 from extensions.ext_database import db
-from fields.workflow_app_log_fields import build_workflow_app_log_pagination_model
+from fields.workflow_app_log_fields import (
+    build_workflow_app_log_pagination_model,
+    build_workflow_archived_log_pagination_model,
+)
 from libs.login import login_required
 from models import App
 from models.model import AppMode
@@ -61,6 +64,7 @@ console_ns.schema_model(
 
 # Register model for flask_restx to avoid dict type issues in Swagger
 workflow_app_log_pagination_model = build_workflow_app_log_pagination_model(console_ns)
+workflow_archived_log_pagination_model = build_workflow_archived_log_pagination_model(console_ns)
 
 
 @console_ns.route("/apps/<uuid:app_id>/workflow-app-logs")
@@ -99,3 +103,33 @@ class WorkflowAppLogApi(Resource):
             )
 
             return workflow_app_log_pagination
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflow-archived-logs")
+class WorkflowArchivedLogApi(Resource):
+    @console_ns.doc("get_workflow_archived_logs")
+    @console_ns.doc(description="Get workflow archived execution logs")
+    @console_ns.doc(params={"app_id": "Application ID"})
+    @console_ns.expect(console_ns.models[WorkflowAppLogQuery.__name__])
+    @console_ns.response(200, "Workflow archived logs retrieved successfully", workflow_archived_log_pagination_model)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.WORKFLOW])
+    @marshal_with(workflow_archived_log_pagination_model)
+    def get(self, app_model: App):
+        """
+        Get workflow archived logs
+        """
+        args = WorkflowAppLogQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore
+
+        workflow_app_service = WorkflowAppService()
+        with Session(db.engine) as session:
+            workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_archive_logs(
+                session=session,
+                app_model=app_model,
+                page=args.page,
+                limit=args.limit,
+            )
+
+            return workflow_app_log_pagination

api/controllers/console/app/workflow_draft_variable.py

@@ -17,7 +17,7 @@ from controllers.console.wraps import account_initialization_required, edit_perm
 from controllers.web.error import InvalidArgumentError, NotFoundError
 from core.file import helpers as file_helpers
 from core.variables.segment_group import SegmentGroup
-from core.variables.segments import ArrayFileSegment, ArrayPromptMessageSegment, FileSegment, Segment
+from core.variables.segments import ArrayFileSegment, FileSegment, Segment
 from core.variables.types import SegmentType
 from core.workflow.constants import CONVERSATION_VARIABLE_NODE_ID, SYSTEM_VARIABLE_NODE_ID
 from extensions.ext_database import db
@@ -58,8 +58,6 @@ def _convert_values_to_json_serializable_object(value: Segment):
         return value.value.model_dump()
     elif isinstance(value, ArrayFileSegment):
         return [i.model_dump() for i in value.value]
-    elif isinstance(value, ArrayPromptMessageSegment):
-        return value.to_object()
     elif isinstance(value, SegmentGroup):
         return [_convert_values_to_json_serializable_object(i) for i in value.value]
     else:

api/controllers/console/app/workflow_run.py

@@ -1,12 +1,15 @@
+from datetime import UTC, datetime, timedelta
 from typing import Literal, cast
 
 from flask import request
 from flask_restx import Resource, fields, marshal_with
 from pydantic import BaseModel, Field, field_validator
+from sqlalchemy import select
 
 from controllers.console import console_ns
 from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
+from extensions.ext_database import db
 from fields.end_user_fields import simple_end_user_fields
 from fields.member_fields import simple_account_fields
 from fields.workflow_run_fields import (
@@ -19,14 +22,17 @@ from fields.workflow_run_fields import (
     workflow_run_node_execution_list_fields,
     workflow_run_pagination_fields,
 )
+from libs.archive_storage import ArchiveStorageNotConfiguredError, get_archive_storage
 from libs.custom_inputs import time_duration
 from libs.helper import uuid_value
 from libs.login import current_user, login_required
-from models import Account, App, AppMode, EndUser, WorkflowRunTriggeredFrom
+from models import Account, App, AppMode, EndUser, WorkflowArchiveLog, WorkflowRunTriggeredFrom
+from services.retention.workflow_run.constants import ARCHIVE_BUNDLE_NAME
 from services.workflow_run_service import WorkflowRunService
 
 # Workflow run status choices for filtering
 WORKFLOW_RUN_STATUS_CHOICES = ["running", "succeeded", "failed", "stopped", "partial-succeeded"]
+EXPORT_SIGNED_URL_EXPIRE_SECONDS = 3600
 
 # Register models for flask_restx to avoid dict type issues in Swagger
 # Register in dependency order: base models first, then dependent models
@@ -93,6 +99,15 @@ workflow_run_node_execution_list_model = console_ns.model(
     "WorkflowRunNodeExecutionList", workflow_run_node_execution_list_fields_copy
 )
 
+workflow_run_export_fields = console_ns.model(
+    "WorkflowRunExport",
+    {
+        "status": fields.String(description="Export status: success/failed"),
+        "presigned_url": fields.String(description="Pre-signed URL for download", required=False),
+        "presigned_url_expires_at": fields.String(description="Pre-signed URL expiration time", required=False),
+    },
+)
+
 DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
 
 
@@ -181,6 +196,56 @@ class AdvancedChatAppWorkflowRunListApi(Resource):
         return result
 
 
+@console_ns.route("/apps/<uuid:app_id>/workflow-runs/<uuid:run_id>/export")
+class WorkflowRunExportApi(Resource):
+    @console_ns.doc("get_workflow_run_export_url")
+    @console_ns.doc(description="Generate a download URL for an archived workflow run.")
+    @console_ns.doc(params={"app_id": "Application ID", "run_id": "Workflow run ID"})
+    @console_ns.response(200, "Export URL generated", workflow_run_export_fields)
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model()
+    def get(self, app_model: App, run_id: str):
+        tenant_id = str(app_model.tenant_id)
+        app_id = str(app_model.id)
+        run_id_str = str(run_id)
+
+        run_created_at = db.session.scalar(
+            select(WorkflowArchiveLog.run_created_at)
+            .where(
+                WorkflowArchiveLog.tenant_id == tenant_id,
+                WorkflowArchiveLog.app_id == app_id,
+                WorkflowArchiveLog.workflow_run_id == run_id_str,
+            )
+            .limit(1)
+        )
+        if not run_created_at:
+            return {"code": "archive_log_not_found", "message": "workflow run archive not found"}, 404
+
+        prefix = (
+            f"{tenant_id}/app_id={app_id}/year={run_created_at.strftime('%Y')}/"
+            f"month={run_created_at.strftime('%m')}/workflow_run_id={run_id_str}"
+        )
+        archive_key = f"{prefix}/{ARCHIVE_BUNDLE_NAME}"
+
+        try:
+            archive_storage = get_archive_storage()
+        except ArchiveStorageNotConfiguredError as e:
+            return {"code": "archive_storage_not_configured", "message": str(e)}, 500
+
+        presigned_url = archive_storage.generate_presigned_url(
+            archive_key,
+            expires_in=EXPORT_SIGNED_URL_EXPIRE_SECONDS,
+        )
+        expires_at = datetime.now(UTC) + timedelta(seconds=EXPORT_SIGNED_URL_EXPIRE_SECONDS)
+        return {
+            "status": "success",
+            "presigned_url": presigned_url,
+            "presigned_url_expires_at": expires_at.isoformat(),
+        }, 200
+
+
 @console_ns.route("/apps/<uuid:app_id>/advanced-chat/workflow-runs/count")
 class AdvancedChatAppWorkflowRunCountApi(Resource):
     @console_ns.doc("get_advanced_chat_workflow_runs_count")

api/controllers/console/datasets/datasets_document.py

@@ -2,10 +2,12 @@ import json
 import logging
 from argparse import ArgumentTypeError
 from collections.abc import Sequence
-from typing import Literal, cast
+from contextlib import ExitStack
+from typing import Any, Literal, cast
+from uuid import UUID
 
 import sqlalchemy as sa
-from flask import request
+from flask import request, send_file
 from flask_restx import Resource, fields, marshal, marshal_with
 from pydantic import BaseModel, Field
 from sqlalchemy import asc, desc, select
@@ -42,6 +44,7 @@ from models import DatasetProcessRule, Document, DocumentSegment, UploadFile
 from models.dataset import DocumentPipelineExecutionLog
 from services.dataset_service import DatasetService, DocumentService
 from services.entities.knowledge_entities.knowledge_entities import KnowledgeConfig, ProcessRule, RetrievalModel
+from services.file_service import FileService
 
 from ..app.error import (
     ProviderModelCurrentlyNotSupportError,
@@ -65,6 +68,9 @@ from ..wraps import (
 
 logger = logging.getLogger(__name__)
 
+# NOTE: Keep constants near the top of the module for discoverability.
+DOCUMENT_BATCH_DOWNLOAD_ZIP_MAX_DOCS = 100
+
 
 def _get_or_create_model(model_name: str, field_def):
     existing = console_ns.models.get(model_name)
@@ -104,6 +110,12 @@ class DocumentRenamePayload(BaseModel):
     name: str
 
 
+class DocumentBatchDownloadZipPayload(BaseModel):
+    """Request payload for bulk downloading documents as a zip archive."""
+
+    document_ids: list[UUID] = Field(..., min_length=1, max_length=DOCUMENT_BATCH_DOWNLOAD_ZIP_MAX_DOCS)
+
+
 class DocumentDatasetListParam(BaseModel):
     page: int = Field(1, title="Page", description="Page number.")
     limit: int = Field(20, title="Limit", description="Page size.")
@@ -120,6 +132,7 @@ register_schema_models(
     RetrievalModel,
     DocumentRetryPayload,
     DocumentRenamePayload,
+    DocumentBatchDownloadZipPayload,
 )
 
 
@@ -853,6 +866,62 @@ class DocumentApi(DocumentResource):
         return {"result": "success"}, 204
 
 
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/download")
+class DocumentDownloadApi(DocumentResource):
+    """Return a signed download URL for a dataset document's original uploaded file."""
+
+    @console_ns.doc("get_dataset_document_download_url")
+    @console_ns.doc(description="Get a signed download URL for a dataset document's original uploaded file")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    def get(self, dataset_id: str, document_id: str) -> dict[str, Any]:
+        # Reuse the shared permission/tenant checks implemented in DocumentResource.
+        document = self.get_document(str(dataset_id), str(document_id))
+        return {"url": DocumentService.get_document_download_url(document)}
+
+
+@console_ns.route("/datasets/<uuid:dataset_id>/documents/download-zip")
+class DocumentBatchDownloadZipApi(DocumentResource):
+    """Download multiple uploaded-file documents as a single ZIP (avoids browser multi-download limits)."""
+
+    @console_ns.doc("download_dataset_documents_as_zip")
+    @console_ns.doc(description="Download selected dataset documents as a single ZIP archive (upload-file only)")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @cloud_edition_billing_rate_limit_check("knowledge")
+    @console_ns.expect(console_ns.models[DocumentBatchDownloadZipPayload.__name__])
+    def post(self, dataset_id: str):
+        """Stream a ZIP archive containing the requested uploaded documents."""
+        # Parse and validate request payload.
+        payload = DocumentBatchDownloadZipPayload.model_validate(console_ns.payload or {})
+
+        current_user, current_tenant_id = current_account_with_tenant()
+        dataset_id = str(dataset_id)
+        document_ids: list[str] = [str(document_id) for document_id in payload.document_ids]
+        upload_files, download_name = DocumentService.prepare_document_batch_download_zip(
+            dataset_id=dataset_id,
+            document_ids=document_ids,
+            tenant_id=current_tenant_id,
+            current_user=current_user,
+        )
+
+        # Delegate ZIP packing to FileService, but keep Flask response+cleanup in the route.
+        with ExitStack() as stack:
+            zip_path = stack.enter_context(FileService.build_upload_files_zip_tempfile(upload_files=upload_files))
+            response = send_file(
+                zip_path,
+                mimetype="application/zip",
+                as_attachment=True,
+                download_name=download_name,
+            )
+            cleanup = stack.pop_all()
+            response.call_on_close(cleanup.close)
+        return response
+
+
 @console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/processing/<string:action>")
 class DocumentProcessingApi(DocumentResource):
     @console_ns.doc("update_document_processing")

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

@@ -82,7 +82,7 @@ class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk
 
     @classmethod
@@ -110,7 +110,7 @@ class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
             }
 
             if isinstance(sub_stream_response, MessageEndStreamResponse):
-                sub_stream_response_dict = sub_stream_response.model_dump(mode="json", exclude_none=True)
+                sub_stream_response_dict = sub_stream_response.model_dump(mode="json")
                 metadata = sub_stream_response_dict.get("metadata", {})
                 sub_stream_response_dict["metadata"] = cls._get_simple_metadata(metadata)
                 response_chunk.update(sub_stream_response_dict)
@@ -120,6 +120,6 @@ class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
             elif isinstance(sub_stream_response, NodeStartStreamResponse | NodeFinishStreamResponse):
                 response_chunk.update(sub_stream_response.to_ignore_detail_dict())
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
 
             yield response_chunk

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

@@ -81,7 +81,7 @@ class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk
 
     @classmethod
@@ -109,7 +109,7 @@ class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter):
             }
 
             if isinstance(sub_stream_response, MessageEndStreamResponse):
-                sub_stream_response_dict = sub_stream_response.model_dump(mode="json", exclude_none=True)
+                sub_stream_response_dict = sub_stream_response.model_dump(mode="json")
                 metadata = sub_stream_response_dict.get("metadata", {})
                 sub_stream_response_dict["metadata"] = cls._get_simple_metadata(metadata)
                 response_chunk.update(sub_stream_response_dict)
@@ -117,6 +117,6 @@ class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
 
             yield response_chunk

api/core/app/apps/chat/generate_response_converter.py

@@ -81,7 +81,7 @@ class ChatAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk
 
     @classmethod
@@ -109,7 +109,7 @@ class ChatAppGenerateResponseConverter(AppGenerateResponseConverter):
             }
 
             if isinstance(sub_stream_response, MessageEndStreamResponse):
-                sub_stream_response_dict = sub_stream_response.model_dump(mode="json", exclude_none=True)
+                sub_stream_response_dict = sub_stream_response.model_dump(mode="json")
                 metadata = sub_stream_response_dict.get("metadata", {})
                 sub_stream_response_dict["metadata"] = cls._get_simple_metadata(metadata)
                 response_chunk.update(sub_stream_response_dict)
@@ -117,6 +117,6 @@ class ChatAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
 
             yield response_chunk

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

@@ -70,8 +70,6 @@ class _NodeSnapshot:
     """Empty string means the node is not executing inside an iteration."""
     loop_id: str = ""
     """Empty string means the node is not executing inside a loop."""
-    mention_parent_id: str = ""
-    """Empty string means the node is not an extractor node."""
 
 
 class WorkflowResponseConverter:
@@ -133,7 +131,6 @@ class WorkflowResponseConverter:
             start_at=event.start_at,
             iteration_id=event.in_iteration_id or "",
             loop_id=event.in_loop_id or "",
-            mention_parent_id=event.in_mention_parent_id or "",
         )
         node_execution_id = NodeExecutionId(event.node_execution_id)
         self._node_snapshots[node_execution_id] = snapshot
@@ -290,7 +287,6 @@ class WorkflowResponseConverter:
                 created_at=int(snapshot.start_at.timestamp()),
                 iteration_id=event.in_iteration_id,
                 loop_id=event.in_loop_id,
-                mention_parent_id=event.in_mention_parent_id,
                 agent_strategy=event.agent_strategy,
             ),
         )
@@ -377,7 +373,6 @@ class WorkflowResponseConverter:
                 files=self.fetch_files_from_node_outputs(event.outputs or {}),
                 iteration_id=event.in_iteration_id,
                 loop_id=event.in_loop_id,
-                mention_parent_id=event.in_mention_parent_id,
             ),
         )
 
@@ -427,7 +422,6 @@ class WorkflowResponseConverter:
                 files=self.fetch_files_from_node_outputs(event.outputs or {}),
                 iteration_id=event.in_iteration_id,
                 loop_id=event.in_loop_id,
-                mention_parent_id=event.in_mention_parent_id,
                 retry_index=event.retry_index,
             ),
         )

api/core/app/apps/completion/generate_response_converter.py

@@ -79,7 +79,7 @@ class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk
 
     @classmethod
@@ -106,7 +106,7 @@ class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter):
             }
 
             if isinstance(sub_stream_response, MessageEndStreamResponse):
-                sub_stream_response_dict = sub_stream_response.model_dump(mode="json", exclude_none=True)
+                sub_stream_response_dict = sub_stream_response.model_dump(mode="json")
                 metadata = sub_stream_response_dict.get("metadata", {})
                 if not isinstance(metadata, dict):
                     metadata = {}
@@ -116,6 +116,6 @@ class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
 
             yield response_chunk

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

@@ -60,7 +60,7 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(cast(dict, data))
             else:
-                response_chunk.update(sub_stream_response.model_dump(exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump())
             yield response_chunk
 
     @classmethod
@@ -91,5 +91,5 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
             elif isinstance(sub_stream_response, NodeStartStreamResponse | NodeFinishStreamResponse):
                 response_chunk.update(cast(dict, sub_stream_response.to_ignore_detail_dict()))
             else:
-                response_chunk.update(sub_stream_response.model_dump(exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump())
             yield response_chunk

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

@@ -60,7 +60,7 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
                 data = cls._error_to_stream_response(sub_stream_response.err)
                 response_chunk.update(data)
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk
 
     @classmethod
@@ -91,5 +91,5 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
             elif isinstance(sub_stream_response, NodeStartStreamResponse | NodeFinishStreamResponse):
                 response_chunk.update(sub_stream_response.to_ignore_detail_dict())
             else:
-                response_chunk.update(sub_stream_response.model_dump(mode="json", exclude_none=True))
+                response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk

api/core/app/apps/workflow_app_runner.py

@@ -385,7 +385,6 @@ class WorkflowBasedAppRunner:
                     start_at=event.start_at,
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                     inputs=inputs,
                     process_data=process_data,
                     outputs=outputs,
@@ -406,7 +405,6 @@ class WorkflowBasedAppRunner:
                     start_at=event.start_at,
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                     agent_strategy=event.agent_strategy,
                     provider_type=event.provider_type,
                     provider_id=event.provider_id,
@@ -430,7 +428,6 @@ class WorkflowBasedAppRunner:
                     execution_metadata=execution_metadata,
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                 )
             )
         elif isinstance(event, NodeRunFailedEvent):
@@ -447,7 +444,6 @@ class WorkflowBasedAppRunner:
                     execution_metadata=event.node_run_result.metadata,
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                 )
             )
         elif isinstance(event, NodeRunExceptionEvent):
@@ -464,7 +460,6 @@ class WorkflowBasedAppRunner:
                     execution_metadata=event.node_run_result.metadata,
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                 )
             )
         elif isinstance(event, NodeRunStreamChunkEvent):
@@ -474,7 +469,6 @@ class WorkflowBasedAppRunner:
                     from_variable_selector=list(event.selector),
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                 )
             )
         elif isinstance(event, NodeRunRetrieverResourceEvent):
@@ -483,7 +477,6 @@ class WorkflowBasedAppRunner:
                     retriever_resources=event.retriever_resources,
                     in_iteration_id=event.in_iteration_id,
                     in_loop_id=event.in_loop_id,
-                    in_mention_parent_id=event.in_mention_parent_id,
                 )
             )
         elif isinstance(event, NodeRunAgentLogEvent):

api/core/app/entities/queue_entities.py

@@ -190,8 +190,6 @@ class QueueTextChunkEvent(AppQueueEvent):
     """iteration id if node is in iteration"""
     in_loop_id: str | None = None
     """loop id if node is in loop"""
-    in_mention_parent_id: str | None = None
-    """parent node id if this is an extractor node event"""
 
 
 class QueueAgentMessageEvent(AppQueueEvent):
@@ -231,8 +229,6 @@ class QueueRetrieverResourcesEvent(AppQueueEvent):
     """iteration id if node is in iteration"""
     in_loop_id: str | None = None
     """loop id if node is in loop"""
-    in_mention_parent_id: str | None = None
-    """parent node id if this is an extractor node event"""
 
 
 class QueueAnnotationReplyEvent(AppQueueEvent):
@@ -310,8 +306,6 @@ class QueueNodeStartedEvent(AppQueueEvent):
     node_run_index: int = 1  # FIXME(-LAN-): may not used
     in_iteration_id: str | None = None
     in_loop_id: str | None = None
-    in_mention_parent_id: str | None = None
-    """parent node id if this is an extractor node event"""
     start_at: datetime
     agent_strategy: AgentNodeStrategyInit | None = None
 
@@ -334,8 +328,6 @@ class QueueNodeSucceededEvent(AppQueueEvent):
     """iteration id if node is in iteration"""
     in_loop_id: str | None = None
     """loop id if node is in loop"""
-    in_mention_parent_id: str | None = None
-    """parent node id if this is an extractor node event"""
     start_at: datetime
 
     inputs: Mapping[str, object] = Field(default_factory=dict)
@@ -391,8 +383,6 @@ class QueueNodeExceptionEvent(AppQueueEvent):
     """iteration id if node is in iteration"""
     in_loop_id: str | None = None
     """loop id if node is in loop"""
-    in_mention_parent_id: str | None = None
-    """parent node id if this is an extractor node event"""
     start_at: datetime
 
     inputs: Mapping[str, object] = Field(default_factory=dict)
@@ -417,8 +407,6 @@ class QueueNodeFailedEvent(AppQueueEvent):
     """iteration id if node is in iteration"""
     in_loop_id: str | None = None
     """loop id if node is in loop"""
-    in_mention_parent_id: str | None = None
-    """parent node id if this is an extractor node event"""
     start_at: datetime
 
     inputs: Mapping[str, object] = Field(default_factory=dict)

api/core/app/entities/task_entities.py

@@ -262,7 +262,6 @@ class NodeStartStreamResponse(StreamResponse):
         extras: dict[str, object] = Field(default_factory=dict)
         iteration_id: str | None = None
         loop_id: str | None = None
-        mention_parent_id: str | None = None
         agent_strategy: AgentNodeStrategyInit | None = None
 
     event: StreamEvent = StreamEvent.NODE_STARTED
@@ -286,7 +285,6 @@ class NodeStartStreamResponse(StreamResponse):
                 "extras": {},
                 "iteration_id": self.data.iteration_id,
                 "loop_id": self.data.loop_id,
-                "mention_parent_id": self.data.mention_parent_id,
             },
         }
 
@@ -322,7 +320,6 @@ class NodeFinishStreamResponse(StreamResponse):
         files: Sequence[Mapping[str, Any]] | None = []
         iteration_id: str | None = None
         loop_id: str | None = None
-        mention_parent_id: str | None = None
 
     event: StreamEvent = StreamEvent.NODE_FINISHED
     workflow_run_id: str
@@ -352,7 +349,6 @@ class NodeFinishStreamResponse(StreamResponse):
                 "files": [],
                 "iteration_id": self.data.iteration_id,
                 "loop_id": self.data.loop_id,
-                "mention_parent_id": self.data.mention_parent_id,
             },
         }
 
@@ -388,7 +384,6 @@ class NodeRetryStreamResponse(StreamResponse):
         files: Sequence[Mapping[str, Any]] | None = []
         iteration_id: str | None = None
         loop_id: str | None = None
-        mention_parent_id: str | None = None
         retry_index: int = 0
 
     event: StreamEvent = StreamEvent.NODE_RETRY
@@ -419,7 +414,6 @@ class NodeRetryStreamResponse(StreamResponse):
                 "files": [],
                 "iteration_id": self.data.iteration_id,
                 "loop_id": self.data.loop_id,
-                "mention_parent_id": self.data.mention_parent_id,
                 "retry_index": self.data.retry_index,
             },
         }

api/core/file/file_manager.py

@@ -1,5 +1,4 @@
 import base64
-import logging
 from collections.abc import Mapping
 
 from configs import dify_config
@@ -11,10 +10,7 @@ from core.model_runtime.entities import (
     TextPromptMessageContent,
     VideoPromptMessageContent,
 )
-from core.model_runtime.entities.message_entities import (
-    MultiModalPromptMessageContent,
-    PromptMessageContentUnionTypes,
-)
+from core.model_runtime.entities.message_entities import PromptMessageContentUnionTypes
 from core.tools.signature import sign_tool_file
 from extensions.ext_storage import storage
 
@@ -22,8 +18,6 @@ from . import helpers
 from .enums import FileAttribute
 from .models import File, FileTransferMethod, FileType
 
-logger = logging.getLogger(__name__)
-
 
 def get_attr(*, file: File, attr: FileAttribute):
     match attr:
@@ -95,8 +89,6 @@ def to_prompt_message_content(
         "format": f.extension.removeprefix("."),
         "mime_type": f.mime_type,
         "filename": f.filename or "",
-        # Encoded file reference for context restoration: "transfer_method:related_id" or "remote:url"
-        "file_ref": _encode_file_ref(f),
     }
     if f.type == FileType.IMAGE:
         params["detail"] = image_detail_config or ImagePromptMessageContent.DETAIL.LOW
@@ -104,17 +96,6 @@ def to_prompt_message_content(
     return prompt_class_map[f.type].model_validate(params)
 
 
-def _encode_file_ref(f: File) -> str | None:
-    """Encode file reference as 'transfer_method:id_or_url' string."""
-    if f.transfer_method == FileTransferMethod.REMOTE_URL:
-        return f"remote:{f.remote_url}" if f.remote_url else None
-    elif f.transfer_method == FileTransferMethod.LOCAL_FILE:
-        return f"local:{f.related_id}" if f.related_id else None
-    elif f.transfer_method == FileTransferMethod.TOOL_FILE:
-        return f"tool:{f.related_id}" if f.related_id else None
-    return None
-
-
 def download(f: File, /):
     if f.transfer_method in (
         FileTransferMethod.TOOL_FILE,
@@ -183,128 +164,3 @@ def _to_url(f: File, /):
         return sign_tool_file(tool_file_id=f.related_id, extension=f.extension)
     else:
         raise ValueError(f"Unsupported transfer method: {f.transfer_method}")
-
-
-def restore_multimodal_content(
-    content: MultiModalPromptMessageContent,
-) -> MultiModalPromptMessageContent:
-    """
-    Restore base64_data or url for multimodal content from file_ref.
-
-    file_ref format: "transfer_method:id_or_url" (e.g., "local:abc123", "remote:https://...")
-
-    Args:
-        content: MultiModalPromptMessageContent with file_ref field
-
-    Returns:
-        MultiModalPromptMessageContent with restored base64_data or url
-    """
-    # Skip if no file reference or content already has data
-    if not content.file_ref:
-        return content
-    if content.base64_data or content.url:
-        return content
-
-    try:
-        file = _build_file_from_ref(
-            file_ref=content.file_ref,
-            file_format=content.format,
-            mime_type=content.mime_type,
-            filename=content.filename,
-        )
-        if not file:
-            return content
-
-        # Restore content based on config
-        if dify_config.MULTIMODAL_SEND_FORMAT == "base64":
-            restored_base64 = _get_encoded_string(file)
-            return content.model_copy(update={"base64_data": restored_base64})
-        else:
-            restored_url = _to_url(file)
-            return content.model_copy(update={"url": restored_url})
-
-    except Exception as e:
-        logger.warning("Failed to restore multimodal content: %s", e)
-        return content
-
-
-def _build_file_from_ref(
-    file_ref: str,
-    file_format: str | None,
-    mime_type: str | None,
-    filename: str | None,
-) -> File | None:
-    """
-    Build a File object from encoded file_ref string.
-
-    Args:
-        file_ref: Encoded reference "transfer_method:id_or_url"
-        file_format: The file format/extension (without dot)
-        mime_type: The mime type
-        filename: The filename
-
-    Returns:
-        File object with storage_key loaded, or None if not found
-    """
-    from sqlalchemy import select
-    from sqlalchemy.orm import Session
-
-    from extensions.ext_database import db
-    from models.model import UploadFile
-    from models.tools import ToolFile
-
-    # Parse file_ref: "method:value"
-    if ":" not in file_ref:
-        logger.warning("Invalid file_ref format: %s", file_ref)
-        return None
-
-    method, value = file_ref.split(":", 1)
-    extension = f".{file_format}" if file_format else None
-
-    if method == "remote":
-        return File(
-            tenant_id="",
-            type=FileType.IMAGE,
-            transfer_method=FileTransferMethod.REMOTE_URL,
-            remote_url=value,
-            extension=extension,
-            mime_type=mime_type,
-            filename=filename,
-            storage_key="",
-        )
-
-    # Query database for storage_key
-    with Session(db.engine) as session:
-        if method == "local":
-            stmt = select(UploadFile).where(UploadFile.id == value)
-            upload_file = session.scalar(stmt)
-            if upload_file:
-                return File(
-                    tenant_id=upload_file.tenant_id,
-                    type=FileType(upload_file.extension)
-                    if hasattr(FileType, upload_file.extension.upper())
-                    else FileType.IMAGE,
-                    transfer_method=FileTransferMethod.LOCAL_FILE,
-                    related_id=value,
-                    extension=extension or ("." + upload_file.extension if upload_file.extension else None),
-                    mime_type=mime_type or upload_file.mime_type,
-                    filename=filename or upload_file.name,
-                    storage_key=upload_file.key,
-                )
-        elif method == "tool":
-            stmt = select(ToolFile).where(ToolFile.id == value)
-            tool_file = session.scalar(stmt)
-            if tool_file:
-                return File(
-                    tenant_id=tool_file.tenant_id,
-                    type=FileType.IMAGE,
-                    transfer_method=FileTransferMethod.TOOL_FILE,
-                    related_id=value,
-                    extension=extension,
-                    mime_type=mime_type or tool_file.mimetype,
-                    filename=filename or tool_file.name,
-                    storage_key=tool_file.file_key,
-                )
-
-    logger.warning("File not found for file_ref: %s", file_ref)
-    return None

api/core/llm_generator/llm_generator.py

@@ -1,16 +1,11 @@
 import json
 import logging
 import re
-from collections.abc import Mapping, Sequence
-from typing import Any, Protocol, cast
+from collections.abc import Sequence
+from typing import Protocol, cast
 
 import json_repair
 
-from core.llm_generator.output_models import (
-    CodeNodeStructuredOutput,
-    InstructionModifyOutput,
-    SuggestedQuestionsOutput,
-)
 from core.llm_generator.output_parser.rule_config_generator import RuleConfigGeneratorOutputParser
 from core.llm_generator.output_parser.suggested_questions_after_answer import SuggestedQuestionsAfterAnswerOutputParser
 from core.llm_generator.prompts import (
@@ -398,432 +393,6 @@ class LLMGenerator:
             logger.exception("Failed to invoke LLM model, model: %s", model_config.get("name"))
             return {"output": "", "error": f"An unexpected error occurred: {str(e)}"}
 
-    @classmethod
-    def generate_with_context(
-        cls,
-        tenant_id: str,
-        workflow_id: str,
-        node_id: str,
-        parameter_name: str,
-        language: str,
-        prompt_messages: list[PromptMessage],
-        model_config: dict,
-    ) -> dict:
-        """
-        Generate extractor code node based on conversation context.
-
-        Args:
-            tenant_id: Tenant/workspace ID
-            workflow_id: Workflow ID
-            node_id: Current tool/llm node ID
-            parameter_name: Parameter name to generate code for
-            language: Code language (python3/javascript)
-            prompt_messages: Multi-turn conversation history (last message is instruction)
-            model_config: Model configuration (provider, name, completion_params)
-
-        Returns:
-            dict with CodeNodeData format:
-            - variables: Input variable selectors
-            - code_language: Code language
-            - code: Generated code
-            - outputs: Output definitions
-            - message: Explanation
-            - error: Error message if any
-        """
-        from sqlalchemy import select
-        from sqlalchemy.orm import Session
-
-        from services.workflow_service import WorkflowService
-
-        # Get workflow
-        with Session(db.engine) as session:
-            stmt = select(App).where(App.id == workflow_id)
-            app = session.scalar(stmt)
-            if not app:
-                return cls._error_response(f"App {workflow_id} not found")
-
-            workflow = WorkflowService().get_draft_workflow(app_model=app)
-            if not workflow:
-                return cls._error_response(f"Workflow for app {workflow_id} not found")
-
-        # Get upstream nodes via edge backtracking
-        upstream_nodes = cls._get_upstream_nodes(workflow.graph_dict, node_id)
-
-        # Get current node info
-        current_node = cls._get_node_by_id(workflow.graph_dict, node_id)
-        if not current_node:
-            return cls._error_response(f"Node {node_id} not found")
-
-        # Get parameter info
-        parameter_info = cls._get_parameter_info(
-            tenant_id=tenant_id,
-            node_data=current_node.get("data", {}),
-            parameter_name=parameter_name,
-        )
-
-        # Build system prompt
-        system_prompt = cls._build_extractor_system_prompt(
-            upstream_nodes=upstream_nodes,
-            current_node=current_node,
-            parameter_info=parameter_info,
-            language=language,
-        )
-
-        # Construct complete prompt_messages with system prompt
-        complete_messages: list[PromptMessage] = [
-            SystemPromptMessage(content=system_prompt),
-            *prompt_messages,
-        ]
-
-        from core.llm_generator.output_parser.structured_output import invoke_llm_with_pydantic_model
-
-        # Get model instance and schema
-        provider = model_config.get("provider", "")
-        model_name = model_config.get("name", "")
-        model_instance = ModelManager().get_model_instance(
-            tenant_id=tenant_id,
-            model_type=ModelType.LLM,
-            provider=provider,
-            model=model_name,
-        )
-
-        model_schema = model_instance.model_type_instance.get_model_schema(model_name, model_instance.credentials)
-        if not model_schema:
-            return cls._error_response(f"Model schema not found for {model_name}")
-
-        model_parameters = model_config.get("completion_params", {})
-        try:
-            response = invoke_llm_with_pydantic_model(
-                provider=provider,
-                model_schema=model_schema,
-                model_instance=model_instance,
-                prompt_messages=complete_messages,
-                output_model=CodeNodeStructuredOutput,
-                model_parameters=model_parameters,
-                stream=False,
-                tenant_id=tenant_id,
-            )
-
-            return cls._parse_code_node_output(
-                response.structured_output, language, parameter_info.get("type", "string")
-            )
-
-        except InvokeError as e:
-            return cls._error_response(str(e))
-        except Exception as e:
-            logger.exception("Failed to generate with context, model: %s", model_config.get("name"))
-            return cls._error_response(f"An unexpected error occurred: {str(e)}")
-
-    @classmethod
-    def _error_response(cls, error: str) -> dict:
-        """Return error response in CodeNodeData format."""
-        return {
-            "variables": [],
-            "code_language": "python3",
-            "code": "",
-            "outputs": {},
-            "message": "",
-            "error": error,
-        }
-
-    @classmethod
-    def generate_suggested_questions(
-        cls,
-        tenant_id: str,
-        workflow_id: str,
-        node_id: str,
-        parameter_name: str,
-        language: str,
-        model_config: dict | None = None,
-    ) -> dict:
-        """
-        Generate suggested questions for context generation.
-
-        Returns dict with questions array and error field.
-        """
-        from sqlalchemy import select
-        from sqlalchemy.orm import Session
-
-        from core.llm_generator.output_parser.structured_output import invoke_llm_with_pydantic_model
-        from services.workflow_service import WorkflowService
-
-        # Get workflow context (reuse existing logic)
-        with Session(db.engine) as session:
-            stmt = select(App).where(App.id == workflow_id)
-            app = session.scalar(stmt)
-            if not app:
-                return {"questions": [], "error": f"App {workflow_id} not found"}
-
-            workflow = WorkflowService().get_draft_workflow(app_model=app)
-            if not workflow:
-                return {"questions": [], "error": f"Workflow for app {workflow_id} not found"}
-
-        upstream_nodes = cls._get_upstream_nodes(workflow.graph_dict, node_id)
-        current_node = cls._get_node_by_id(workflow.graph_dict, node_id)
-        if not current_node:
-            return {"questions": [], "error": f"Node {node_id} not found"}
-
-        parameter_info = cls._get_parameter_info(
-            tenant_id=tenant_id,
-            node_data=current_node.get("data", {}),
-            parameter_name=parameter_name,
-        )
-
-        # Build prompt
-        system_prompt = cls._build_suggested_questions_prompt(
-            upstream_nodes=upstream_nodes,
-            current_node=current_node,
-            parameter_info=parameter_info,
-            language=language,
-        )
-
-        prompt_messages: list[PromptMessage] = [
-            SystemPromptMessage(content=system_prompt),
-        ]
-
-        # Get model instance - use default if model_config not provided
-        model_manager = ModelManager()
-        if model_config:
-            provider = model_config.get("provider", "")
-            model_name = model_config.get("name", "")
-            model_instance = model_manager.get_model_instance(
-                tenant_id=tenant_id,
-                model_type=ModelType.LLM,
-                provider=provider,
-                model=model_name,
-            )
-        else:
-            model_instance = model_manager.get_default_model_instance(
-                tenant_id=tenant_id,
-                model_type=ModelType.LLM,
-            )
-            model_name = model_instance.model
-
-        model_schema = model_instance.model_type_instance.get_model_schema(model_name, model_instance.credentials)
-        if not model_schema:
-            return {"questions": [], "error": f"Model schema not found for {model_name}"}
-
-        completion_params = model_config.get("completion_params", {}) if model_config else {}
-        model_parameters = {**completion_params, "max_tokens": 256}
-        try:
-            response = invoke_llm_with_pydantic_model(
-                provider=model_instance.provider,
-                model_schema=model_schema,
-                model_instance=model_instance,
-                prompt_messages=prompt_messages,
-                output_model=SuggestedQuestionsOutput,
-                model_parameters=model_parameters,
-                stream=False,
-                tenant_id=tenant_id,
-            )
-
-            questions = response.structured_output.get("questions", []) if response.structured_output else []
-            return {"questions": questions, "error": ""}
-
-        except InvokeError as e:
-            return {"questions": [], "error": str(e)}
-        except Exception as e:
-            logger.exception("Failed to generate suggested questions, model: %s", model_name)
-            return {"questions": [], "error": f"An unexpected error occurred: {str(e)}"}
-
-    @classmethod
-    def _build_suggested_questions_prompt(
-        cls,
-        upstream_nodes: list[dict],
-        current_node: dict,
-        parameter_info: dict,
-        language: str = "English",
-    ) -> str:
-        """Build minimal prompt for suggested questions generation."""
-        # Simplify upstream nodes to reduce tokens
-        sources = [f"{n['title']}({','.join(n.get('outputs', {}).keys())})" for n in upstream_nodes[:5]]
-        param_type = parameter_info.get("type", "string")
-        param_desc = parameter_info.get("description", "")[:100]
-
-        return f"""Suggest 3 code generation questions for extracting data.
-Sources: {", ".join(sources)}
-Target: {parameter_info.get("name")}({param_type}) - {param_desc}
-Output 3 short, practical questions in {language}."""
-
-    @classmethod
-    def _get_upstream_nodes(cls, graph_dict: Mapping[str, Any], node_id: str) -> list[dict]:
-        """
-        Get all upstream nodes via edge backtracking.
-
-        Traverses the graph backwards from node_id to collect all reachable nodes.
-        """
-        from collections import defaultdict
-
-        nodes = {n["id"]: n for n in graph_dict.get("nodes", [])}
-        edges = graph_dict.get("edges", [])
-
-        # Build reverse adjacency list
-        reverse_adj: dict[str, list[str]] = defaultdict(list)
-        for edge in edges:
-            reverse_adj[edge["target"]].append(edge["source"])
-
-        # BFS to find all upstream nodes
-        visited: set[str] = set()
-        queue = [node_id]
-        upstream: list[dict] = []
-
-        while queue:
-            current = queue.pop(0)
-            for source in reverse_adj.get(current, []):
-                if source not in visited:
-                    visited.add(source)
-                    queue.append(source)
-                    if source in nodes:
-                        upstream.append(cls._extract_node_info(nodes[source]))
-
-        return upstream
-
-    @classmethod
-    def _get_node_by_id(cls, graph_dict: Mapping[str, Any], node_id: str) -> dict | None:
-        """Get node by ID from graph."""
-        for node in graph_dict.get("nodes", []):
-            if node["id"] == node_id:
-                return node
-        return None
-
-    @classmethod
-    def _extract_node_info(cls, node: dict) -> dict:
-        """Extract minimal node info with outputs based on node type."""
-        node_type = node["data"]["type"]
-        node_data = node.get("data", {})
-
-        # Build outputs based on node type (only type, no description to reduce tokens)
-        outputs: dict[str, str] = {}
-        match node_type:
-            case "start":
-                for var in node_data.get("variables", []):
-                    name = var.get("variable", var.get("name", ""))
-                    outputs[name] = var.get("type", "string")
-            case "llm":
-                outputs["text"] = "string"
-            case "code":
-                for name, output in node_data.get("outputs", {}).items():
-                    outputs[name] = output.get("type", "string")
-            case "http-request":
-                outputs = {"body": "string", "status_code": "number", "headers": "object"}
-            case "knowledge-retrieval":
-                outputs["result"] = "array[object]"
-            case "tool":
-                outputs = {"text": "string", "json": "object"}
-            case _:
-                outputs["output"] = "string"
-
-        info: dict = {
-            "id": node["id"],
-            "title": node_data.get("title", node["id"]),
-            "outputs": outputs,
-        }
-        # Only include description if not empty
-        desc = node_data.get("desc", "")
-        if desc:
-            info["desc"] = desc
-
-        return info
-
-    @classmethod
-    def _get_parameter_info(cls, tenant_id: str, node_data: dict, parameter_name: str) -> dict:
-        """Get parameter info from tool schema using ToolManager."""
-        default_info = {"name": parameter_name, "type": "string", "description": ""}
-
-        if node_data.get("type") != "tool":
-            return default_info
-
-        try:
-            from core.app.entities.app_invoke_entities import InvokeFrom
-            from core.tools.entities.tool_entities import ToolProviderType
-            from core.tools.tool_manager import ToolManager
-
-            provider_type_str = node_data.get("provider_type", "")
-            provider_type = ToolProviderType(provider_type_str) if provider_type_str else ToolProviderType.BUILT_IN
-
-            tool_runtime = ToolManager.get_tool_runtime(
-                provider_type=provider_type,
-                provider_id=node_data.get("provider_id", ""),
-                tool_name=node_data.get("tool_name", ""),
-                tenant_id=tenant_id,
-                invoke_from=InvokeFrom.DEBUGGER,
-            )
-
-            parameters = tool_runtime.get_merged_runtime_parameters()
-            for param in parameters:
-                if param.name == parameter_name:
-                    return {
-                        "name": param.name,
-                        "type": param.type.value if hasattr(param.type, "value") else str(param.type),
-                        "description": param.llm_description
-                        or (param.human_description.en_US if param.human_description else ""),
-                        "required": param.required,
-                    }
-        except Exception as e:
-            logger.debug("Failed to get parameter info from ToolManager: %s", e)
-
-        return default_info
-
-    @classmethod
-    def _build_extractor_system_prompt(
-        cls,
-        upstream_nodes: list[dict],
-        current_node: dict,
-        parameter_info: dict,
-        language: str,
-    ) -> str:
-        """Build system prompt for extractor code generation."""
-        upstream_json = json.dumps(upstream_nodes, indent=2, ensure_ascii=False)
-        param_type = parameter_info.get("type", "string")
-        return f"""You are a code generator for workflow automation.
-
-Generate {language} code to extract/transform upstream node outputs for the target parameter.
-
-## Upstream Nodes
-{upstream_json}
-
-## Target
-Node: {current_node["data"].get("title", current_node["id"])}
-Parameter: {parameter_info.get("name")} ({param_type}) - {parameter_info.get("description", "")}
-
-## Requirements
-- Write a main function that returns type: {param_type}
-- Use value_selector format: ["node_id", "output_name"]
-"""
-
-    @classmethod
-    def _parse_code_node_output(cls, content: Mapping[str, Any] | None, language: str, parameter_type: str) -> dict:
-        """
-        Parse structured output to CodeNodeData format.
-
-        Args:
-            content: Structured output dict from invoke_llm_with_structured_output
-            language: Code language
-            parameter_type: Expected parameter type
-
-        Returns dict with variables, code_language, code, outputs, message, error.
-        """
-        if content is None:
-            return cls._error_response("Empty or invalid response from LLM")
-
-        # Validate and normalize variables
-        variables = [
-            {"variable": v.get("variable", ""), "value_selector": v.get("value_selector", [])}
-            for v in content.get("variables", [])
-            if isinstance(v, dict)
-        ]
-
-        outputs = content.get("outputs", {"result": {"type": parameter_type}})
-
-        return {
-            "variables": variables,
-            "code_language": language,
-            "code": content.get("code", ""),
-            "outputs": outputs,
-            "message": content.get("explanation", ""),
-            "error": "",
-        }
-
     @staticmethod
     def instruction_modify_legacy(
         tenant_id: str, flow_id: str, current: str, instruction: str, model_config: dict, ideal_output: str | None
@@ -960,10 +529,6 @@ Parameter: {parameter_info.get("name")} ({param_type}) - {parameter_info.get("de
             provider=model_config.get("provider", ""),
             model=model_config.get("name", ""),
         )
-        model_name = model_config.get("name", "")
-        model_schema = model_instance.model_type_instance.get_model_schema(model_name, model_instance.credentials)
-        if not model_schema:
-            return {"error": f"Model schema not found for {model_name}"}
         match node_type:
             case "llm" | "agent":
                 system_prompt = LLM_MODIFY_PROMPT_SYSTEM
@@ -987,18 +552,20 @@ Parameter: {parameter_info.get("name")} ({param_type}) - {parameter_info.get("de
         model_parameters = {"temperature": 0.4}
 
         try:
-            from core.llm_generator.output_parser.structured_output import invoke_llm_with_pydantic_model
-
-            response = invoke_llm_with_pydantic_model(
-                provider=model_instance.provider,
-                model_schema=model_schema,
-                model_instance=model_instance,
-                prompt_messages=list(prompt_messages),
-                output_model=InstructionModifyOutput,
-                model_parameters=model_parameters,
-                stream=False,
+            response: LLMResult = model_instance.invoke_llm(
+                prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
             )
-            return response.structured_output or {}
+
+            generated_raw = response.message.get_text_content()
+            first_brace = generated_raw.find("{")
+            last_brace = generated_raw.rfind("}")
+            if first_brace == -1 or last_brace == -1 or last_brace < first_brace:
+                raise ValueError(f"Could not find a valid JSON object in response: {generated_raw}")
+            json_str = generated_raw[first_brace : last_brace + 1]
+            data = json_repair.loads(json_str)
+            if not isinstance(data, dict):
+                raise TypeError(f"Expected a JSON object, but got {type(data).__name__}")
+            return data
         except InvokeError as e:
             error = str(e)
             return {"error": f"Failed to generate code. Error: {error}"}

api/core/llm_generator/output_models.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from core.variables.types import SegmentType
-from core.workflow.nodes.base.entities import VariableSelector
-
-
-class SuggestedQuestionsOutput(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    questions: list[str] = Field(min_length=3, max_length=3)
-
-
-class CodeNodeOutput(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    type: SegmentType
-
-
-class CodeNodeStructuredOutput(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    variables: list[VariableSelector]
-    code: str
-    outputs: dict[str, CodeNodeOutput]
-    explanation: str
-
-
-class InstructionModifyOutput(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    modified: str
-    message: str

api/core/llm_generator/output_parser/file_ref.py

@@ -1,188 +0,0 @@
-"""
-File reference detection and conversion for structured output.
-
-This module provides utilities to:
-1. Detect file reference fields in JSON Schema (format: "dify-file-ref")
-2. Convert file ID strings to File objects after LLM returns
-"""
-
-import uuid
-from collections.abc import Mapping
-from typing import Any
-
-from core.file import File
-from core.variables.segments import ArrayFileSegment, FileSegment
-from factories.file_factory import build_from_mapping
-
-FILE_REF_FORMAT = "dify-file-ref"
-
-
-def is_file_ref_property(schema: dict) -> bool:
-    """Check if a schema property is a file reference."""
-    return schema.get("type") == "string" and schema.get("format") == FILE_REF_FORMAT
-
-
-def detect_file_ref_fields(schema: Mapping[str, Any], path: str = "") -> list[str]:
-    """
-    Recursively detect file reference fields in schema.
-
-    Args:
-        schema: JSON Schema to analyze
-        path: Current path in the schema (used for recursion)
-
-    Returns:
-        List of JSON paths containing file refs, e.g., ["image_id", "files[*]"]
-    """
-    file_ref_paths: list[str] = []
-    schema_type = schema.get("type")
-
-    if schema_type == "object":
-        for prop_name, prop_schema in schema.get("properties", {}).items():
-            current_path = f"{path}.{prop_name}" if path else prop_name
-
-            if is_file_ref_property(prop_schema):
-                file_ref_paths.append(current_path)
-            elif isinstance(prop_schema, dict):
-                file_ref_paths.extend(detect_file_ref_fields(prop_schema, current_path))
-
-    elif schema_type == "array":
-        items_schema = schema.get("items", {})
-        array_path = f"{path}[*]" if path else "[*]"
-
-        if is_file_ref_property(items_schema):
-            file_ref_paths.append(array_path)
-        elif isinstance(items_schema, dict):
-            file_ref_paths.extend(detect_file_ref_fields(items_schema, array_path))
-
-    return file_ref_paths
-
-
-def convert_file_refs_in_output(
-    output: Mapping[str, Any],
-    json_schema: Mapping[str, Any],
-    tenant_id: str,
-) -> dict[str, Any]:
-    """
-    Convert file ID strings to File objects based on schema.
-
-    Args:
-        output: The structured_output from LLM result
-        json_schema: The original JSON schema (to detect file ref fields)
-        tenant_id: Tenant ID for file lookup
-
-    Returns:
-        Output with file references converted to File objects
-    """
-    file_ref_paths = detect_file_ref_fields(json_schema)
-    if not file_ref_paths:
-        return dict(output)
-
-    result = _deep_copy_dict(output)
-
-    for path in file_ref_paths:
-        _convert_path_in_place(result, path.split("."), tenant_id)
-
-    return result
-
-
-def _deep_copy_dict(obj: Mapping[str, Any]) -> dict[str, Any]:
-    """Deep copy a mapping to a mutable dict."""
-    result: dict[str, Any] = {}
-    for key, value in obj.items():
-        if isinstance(value, Mapping):
-            result[key] = _deep_copy_dict(value)
-        elif isinstance(value, list):
-            result[key] = [_deep_copy_dict(item) if isinstance(item, Mapping) else item for item in value]
-        else:
-            result[key] = value
-    return result
-
-
-def _convert_path_in_place(obj: dict, path_parts: list[str], tenant_id: str) -> None:
-    """Convert file refs at the given path in place, wrapping in Segment types."""
-    if not path_parts:
-        return
-
-    current = path_parts[0]
-    remaining = path_parts[1:]
-
-    # Handle array notation like "files[*]"
-    if current.endswith("[*]"):
-        key = current[:-3] if current != "[*]" else None
-        target = obj.get(key) if key else obj
-
-        if isinstance(target, list):
-            if remaining:
-                # Nested array with remaining path - recurse into each item
-                for item in target:
-                    if isinstance(item, dict):
-                        _convert_path_in_place(item, remaining, tenant_id)
-            else:
-                # Array of file IDs - convert all and wrap in ArrayFileSegment
-                files: list[File] = []
-                for item in target:
-                    file = _convert_file_id(item, tenant_id)
-                    if file is not None:
-                        files.append(file)
-                # Replace the array with ArrayFileSegment
-                if key:
-                    obj[key] = ArrayFileSegment(value=files)
-        return
-
-    if not remaining:
-        # Leaf node - convert the value and wrap in FileSegment
-        if current in obj:
-            file = _convert_file_id(obj[current], tenant_id)
-            if file is not None:
-                obj[current] = FileSegment(value=file)
-            else:
-                obj[current] = None
-    else:
-        # Recurse into nested object
-        if current in obj and isinstance(obj[current], dict):
-            _convert_path_in_place(obj[current], remaining, tenant_id)
-
-
-def _convert_file_id(file_id: Any, tenant_id: str) -> File | None:
-    """
-    Convert a file ID string to a File object.
-
-    Tries multiple file sources in order:
-    1. ToolFile (files generated by tools/workflows)
-    2. UploadFile (files uploaded by users)
-    """
-    if not isinstance(file_id, str):
-        return None
-
-    # Validate UUID format
-    try:
-        uuid.UUID(file_id)
-    except ValueError:
-        return None
-
-    # Try ToolFile first (files generated by tools/workflows)
-    try:
-        return build_from_mapping(
-            mapping={
-                "transfer_method": "tool_file",
-                "tool_file_id": file_id,
-            },
-            tenant_id=tenant_id,
-        )
-    except ValueError:
-        pass
-
-    # Try UploadFile (files uploaded by users)
-    try:
-        return build_from_mapping(
-            mapping={
-                "transfer_method": "local_file",
-                "upload_file_id": file_id,
-            },
-            tenant_id=tenant_id,
-        )
-    except ValueError:
-        pass
-
-    # File not found in any source
-    return None

api/core/llm_generator/output_parser/structured_output.py

@@ -2,13 +2,12 @@ import json
 from collections.abc import Generator, Mapping, Sequence
 from copy import deepcopy
 from enum import StrEnum
-from typing import Any, Literal, TypeVar, cast, overload
+from typing import Any, Literal, cast, overload
 
 import json_repair
-from pydantic import BaseModel, TypeAdapter, ValidationError
+from pydantic import TypeAdapter, ValidationError
 
 from core.llm_generator.output_parser.errors import OutputParserError
-from core.llm_generator.output_parser.file_ref import convert_file_refs_in_output
 from core.llm_generator.prompts import STRUCTURED_OUTPUT_PROMPT
 from core.model_manager import ModelInstance
 from core.model_runtime.callbacks.base_callback import Callback
@@ -44,9 +43,6 @@ class SpecialModelType(StrEnum):
     OLLAMA = "ollama"
 
 
-T = TypeVar("T", bound=BaseModel)
-
-
 @overload
 def invoke_llm_with_structured_output(
     *,
@@ -61,7 +57,6 @@ def invoke_llm_with_structured_output(
     stream: Literal[True],
     user: str | None = None,
     callbacks: list[Callback] | None = None,
-    tenant_id: str | None = None,
 ) -> Generator[LLMResultChunkWithStructuredOutput, None, None]: ...
 @overload
 def invoke_llm_with_structured_output(
@@ -77,7 +72,6 @@ def invoke_llm_with_structured_output(
     stream: Literal[False],
     user: str | None = None,
     callbacks: list[Callback] | None = None,
-    tenant_id: str | None = None,
 ) -> LLMResultWithStructuredOutput: ...
 @overload
 def invoke_llm_with_structured_output(
@@ -93,7 +87,6 @@ def invoke_llm_with_structured_output(
     stream: bool = True,
     user: str | None = None,
     callbacks: list[Callback] | None = None,
-    tenant_id: str | None = None,
 ) -> LLMResultWithStructuredOutput | Generator[LLMResultChunkWithStructuredOutput, None, None]: ...
 def invoke_llm_with_structured_output(
     *,
@@ -108,30 +101,23 @@ def invoke_llm_with_structured_output(
     stream: bool = True,
     user: str | None = None,
     callbacks: list[Callback] | None = None,
-    tenant_id: str | None = None,
 ) -> LLMResultWithStructuredOutput | Generator[LLMResultChunkWithStructuredOutput, None, None]:
     """
-    Invoke large language model with structured output.
+    Invoke large language model with structured output
+    1. This method invokes model_instance.invoke_llm with json_schema
+    2. Try to parse the result as structured output
 
-    This method invokes model_instance.invoke_llm with json_schema and parses
-    the result as structured output.
-
-    :param provider: model provider name
-    :param model_schema: model schema entity
-    :param model_instance: model instance to invoke
     :param prompt_messages: prompt messages
-    :param json_schema: json schema for structured output
+    :param json_schema: json schema
     :param model_parameters: model parameters
     :param tools: tools for tool calling
     :param stop: stop words
     :param stream: is stream response
     :param user: unique user id
     :param callbacks: callbacks
-    :param tenant_id: tenant ID for file reference conversion. When provided and
-                      json_schema contains file reference fields (format: "dify-file-ref"),
-                      file IDs in the output will be automatically converted to File objects.
     :return: full response or stream response chunk generator result
     """
+
     # handle native json schema
     model_parameters_with_json_schema: dict[str, Any] = {
         **(model_parameters or {}),
@@ -167,18 +153,8 @@ def invoke_llm_with_structured_output(
                 f"Failed to parse structured output, LLM result is not a string: {llm_result.message.content}"
             )
 
-        structured_output = _parse_structured_output(llm_result.message.content)
-
-        # Convert file references if tenant_id is provided
-        if tenant_id is not None:
-            structured_output = convert_file_refs_in_output(
-                output=structured_output,
-                json_schema=json_schema,
-                tenant_id=tenant_id,
-            )
-
         return LLMResultWithStructuredOutput(
-            structured_output=structured_output,
+            structured_output=_parse_structured_output(llm_result.message.content),
             model=llm_result.model,
             message=llm_result.message,
             usage=llm_result.usage,
@@ -210,18 +186,8 @@ def invoke_llm_with_structured_output(
                     delta=event.delta,
                 )
 
-            structured_output = _parse_structured_output(result_text)
-
-            # Convert file references if tenant_id is provided
-            if tenant_id is not None:
-                structured_output = convert_file_refs_in_output(
-                    output=structured_output,
-                    json_schema=json_schema,
-                    tenant_id=tenant_id,
-                )
-
             yield LLMResultChunkWithStructuredOutput(
-                structured_output=structured_output,
+                structured_output=_parse_structured_output(result_text),
                 model=model_schema.model,
                 prompt_messages=prompt_messages,
                 system_fingerprint=system_fingerprint,
@@ -236,87 +202,6 @@ def invoke_llm_with_structured_output(
         return generator()
 
 
-@overload
-def invoke_llm_with_pydantic_model(
-    *,
-    provider: str,
-    model_schema: AIModelEntity,
-    model_instance: ModelInstance,
-    prompt_messages: Sequence[PromptMessage],
-    output_model: type[T],
-    model_parameters: Mapping | None = None,
-    tools: Sequence[PromptMessageTool] | None = None,
-    stop: list[str] | None = None,
-    stream: Literal[False] = False,
-    user: str | None = None,
-    callbacks: list[Callback] | None = None,
-    tenant_id: str | None = None,
-) -> LLMResultWithStructuredOutput: ...
-
-
-def invoke_llm_with_pydantic_model(
-    *,
-    provider: str,
-    model_schema: AIModelEntity,
-    model_instance: ModelInstance,
-    prompt_messages: Sequence[PromptMessage],
-    output_model: type[T],
-    model_parameters: Mapping | None = None,
-    tools: Sequence[PromptMessageTool] | None = None,
-    stop: list[str] | None = None,
-    stream: bool = False,
-    user: str | None = None,
-    callbacks: list[Callback] | None = None,
-    tenant_id: str | None = None,
-) -> LLMResultWithStructuredOutput:
-    """
-    Invoke large language model with a Pydantic output model.
-
-    This helper generates a JSON schema from the Pydantic model, invokes the
-    structured-output LLM path, and validates the result in non-streaming mode.
-    """
-    if stream:
-        raise ValueError("invoke_llm_with_pydantic_model only supports stream=False")
-
-    json_schema = _schema_from_pydantic(output_model)
-    result = invoke_llm_with_structured_output(
-        provider=provider,
-        model_schema=model_schema,
-        model_instance=model_instance,
-        prompt_messages=prompt_messages,
-        json_schema=json_schema,
-        model_parameters=model_parameters,
-        tools=tools,
-        stop=stop,
-        stream=False,
-        user=user,
-        callbacks=callbacks,
-        tenant_id=tenant_id,
-    )
-
-    structured_output = result.structured_output
-    if structured_output is None:
-        raise OutputParserError("Structured output is empty")
-
-    validated_output = _validate_structured_output(output_model, structured_output)
-    return result.model_copy(update={"structured_output": validated_output})
-
-
-def _schema_from_pydantic(output_model: type[BaseModel]) -> dict[str, Any]:
-    return output_model.model_json_schema()
-
-
-def _validate_structured_output(
-    output_model: type[T],
-    structured_output: Mapping[str, Any],
-) -> dict[str, Any]:
-    try:
-        validated_output = output_model.model_validate(structured_output)
-    except ValidationError as exc:
-        raise OutputParserError(f"Structured output validation failed: {exc}") from exc
-    return validated_output.model_dump(mode="python")
-
-
 def _handle_native_json_schema(
     provider: str,
     model_schema: AIModelEntity,

api/core/llm_generator/utils.py

@@ -1,45 +0,0 @@
-"""Utility functions for LLM generator."""
-
-from core.model_runtime.entities.message_entities import (
-    AssistantPromptMessage,
-    PromptMessage,
-    PromptMessageRole,
-    SystemPromptMessage,
-    ToolPromptMessage,
-    UserPromptMessage,
-)
-
-
-def deserialize_prompt_messages(messages: list[dict]) -> list[PromptMessage]:
-    """
-    Deserialize list of dicts to list[PromptMessage].
-
-    Expected format:
-        [
-            {"role": "user", "content": "..."},
-            {"role": "assistant", "content": "..."},
-        ]
-    """
-    result: list[PromptMessage] = []
-    for msg in messages:
-        role = PromptMessageRole.value_of(msg["role"])
-        content = msg.get("content", "")
-
-        match role:
-            case PromptMessageRole.USER:
-                result.append(UserPromptMessage(content=content))
-            case PromptMessageRole.ASSISTANT:
-                result.append(AssistantPromptMessage(content=content))
-            case PromptMessageRole.SYSTEM:
-                result.append(SystemPromptMessage(content=content))
-            case PromptMessageRole.TOOL:
-                result.append(ToolPromptMessage(content=content, tool_call_id=msg.get("tool_call_id", "")))
-
-    return result
-
-
-def serialize_prompt_messages(messages: list[PromptMessage]) -> list[dict]:
-    """
-    Serialize list[PromptMessage] to list of dicts.
-    """
-    return [{"role": msg.role.value, "content": msg.content} for msg in messages]

api/core/memory/README.md

@@ -1,267 +0,0 @@
-# Memory Module
-
-This module provides memory management for LLM conversations, enabling context retention across dialogue turns.
-
-## Overview
-
-The memory module contains two types of memory implementations:
-
-1. **TokenBufferMemory** - Conversation-level memory (existing)
-2. **NodeTokenBufferMemory** - Node-level memory (**Chatflow only**)
-
-> **Note**: `NodeTokenBufferMemory` is only available in **Chatflow** (advanced-chat mode).
-> This is because it requires both `conversation_id` and `node_id`, which are only present in Chatflow.
-> Standard Workflow mode does not have `conversation_id` and therefore cannot use node-level memory.
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                           Memory Architecture                               │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─────────────────────────────────────────────────────────────────────-┐   │
-│  │                      TokenBufferMemory                               │   │
-│  │  Scope: Conversation                                                 │   │
-│  │  Storage: Database (Message table)                                   │   │
-│  │  Key: conversation_id                                                │   │
-│  └─────────────────────────────────────────────────────────────────────-┘   │
-│                                                                             │
-│  ┌─────────────────────────────────────────────────────────────────────-┐   │
-│  │                    NodeTokenBufferMemory                             │   │
-│  │  Scope: Node within Conversation                                     │   │
-│  │  Storage: WorkflowNodeExecutionModel.outputs["context"]              │   │
-│  │  Key: (conversation_id, node_id, workflow_run_id)                    │   │
-│  └─────────────────────────────────────────────────────────────────────-┘   │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## TokenBufferMemory (Existing)
-
-### Purpose
-
-`TokenBufferMemory` retrieves conversation history from the `Message` table and converts it to `PromptMessage` objects for LLM context.
-
-### Key Features
-
-- **Conversation-scoped**: All messages within a conversation are candidates
-- **Thread-aware**: Uses `parent_message_id` to extract only the current thread (supports regeneration scenarios)
-- **Token-limited**: Truncates history to fit within `max_token_limit`
-- **File support**: Handles `MessageFile` attachments (images, documents, etc.)
-
-### Data Flow
-
-```
-Message Table                    TokenBufferMemory              LLM
-     │                                  │                        │
-     │  SELECT * FROM messages          │                        │
-     │  WHERE conversation_id = ?       │                        │
-     │  ORDER BY created_at DESC        │                        │
-     ├─────────────────────────────────▶│                        │
-     │                                  │                        │
-     │                    extract_thread_messages()              │
-     │                                  │                        │
-     │                    build_prompt_message_with_files()      │
-     │                                  │                        │
-     │                    truncate by max_token_limit            │
-     │                                  │                        │
-     │                                  │  Sequence[PromptMessage]
-     │                                  ├───────────────────────▶│
-     │                                  │                        │
-```
-
-### Thread Extraction
-
-When a user regenerates a response, a new thread is created:
-
-```
-Message A (user)
-    └── Message A' (assistant)
-            └── Message B (user)
-                    └── Message B' (assistant)
-            └── Message A'' (assistant, regenerated)  ← New thread
-                    └── Message C (user)
-                            └── Message C' (assistant)
-```
-
-`extract_thread_messages()` traces back from the latest message using `parent_message_id` to get only the current thread: `[A, A'', C, C']`
-
-### Usage
-
-```python
-from core.memory.token_buffer_memory import TokenBufferMemory
-
-memory = TokenBufferMemory(conversation=conversation, model_instance=model_instance)
-history = memory.get_history_prompt_messages(max_token_limit=2000, message_limit=100)
-```
-
----
-
-## NodeTokenBufferMemory
-
-### Purpose
-
-`NodeTokenBufferMemory` provides **node-scoped memory** within a conversation. Each LLM node in a workflow can maintain its own independent conversation history.
-
-### Use Cases
-
-1. **Multi-LLM Workflows**: Different LLM nodes need separate context
-2. **Iterative Processing**: An LLM node in a loop needs to accumulate context across iterations
-3. **Specialized Agents**: Each agent node maintains its own dialogue history
-
-### Design: Zero Extra Storage
-
-**Key insight**: LLM node already saves complete context in `outputs["context"]`.
-
-Each LLM node execution outputs:
-```python
-outputs = {
-    "text": clean_text,
-    "context": self._build_context(prompt_messages, clean_text),  # Complete dialogue history!
-    ...
-}
-```
-
-This `outputs["context"]` contains:
-- All previous user/assistant messages (excluding system prompt)
-- The current assistant response
-
-**No separate storage needed** - we just read from the last execution's `outputs["context"]`.
-
-### Benefits
-
-| Aspect | Old Design (Object Storage) | New Design (outputs["context"]) |
-|--------|----------------------------|--------------------------------|
-| Storage | Separate JSON file | Already in WorkflowNodeExecutionModel |
-| Concurrency | Race condition risk | No issue (each execution is INSERT) |
-| Cleanup | Need separate cleanup task | Follows node execution lifecycle |
-| Migration | Required | None |
-| Complexity | High | Low |
-
-### Data Flow
-
-```
-WorkflowNodeExecutionModel        NodeTokenBufferMemory           LLM Node
-     │                                  │                           │
-     │                                  │◀── get_history_prompt_messages()
-     │                                  │                           │
-     │  SELECT outputs FROM             │                           │
-     │  workflow_node_executions        │                           │
-     │  WHERE workflow_run_id = ?       │                           │
-     │  AND node_id = ?                 │                           │
-     │◀─────────────────────────────────┤                           │
-     │                                  │                           │
-     │  outputs["context"]              │                           │
-     ├─────────────────────────────────▶│                           │
-     │                                  │                           │
-     │                    deserialize PromptMessages                │
-     │                                  │                           │
-     │                    truncate by max_token_limit               │
-     │                                  │                           │
-     │                                  │  Sequence[PromptMessage]  │
-     │                                  ├──────────────────────────▶│
-     │                                  │                           │
-```
-
-### Thread Tracking
-
-Thread extraction still uses `Message` table's `parent_message_id` structure:
-
-1. Query `Message` table for conversation → get thread's `workflow_run_ids`
-2. Get the last completed `workflow_run_id` in the thread
-3. Query `WorkflowNodeExecutionModel` for that execution's `outputs["context"]`
-
-### API
-
-```python
-class NodeTokenBufferMemory:
-    def __init__(
-        self,
-        app_id: str,
-        conversation_id: str,
-        node_id: str,
-        tenant_id: str,
-        model_instance: ModelInstance,
-    ):
-        """Initialize node-level memory."""
-        ...
-
-    def get_history_prompt_messages(
-        self,
-        *,
-        max_token_limit: int = 2000,
-        message_limit: int | None = None,
-    ) -> Sequence[PromptMessage]:
-        """
-        Retrieve history as PromptMessage sequence.
-        
-        Reads from last completed execution's outputs["context"].
-        """
-        ...
-
-    # Legacy methods (no-op, kept for compatibility)
-    def add_messages(self, *args, **kwargs) -> None: pass
-    def flush(self) -> None: pass
-    def clear(self) -> None: pass
-```
-
-### Configuration
-
-Add to `MemoryConfig` in `core/workflow/nodes/llm/entities.py`:
-
-```python
-class MemoryMode(StrEnum):
-    CONVERSATION = "conversation"  # Use TokenBufferMemory (default)
-    NODE = "node"                  # Use NodeTokenBufferMemory (Chatflow only)
-
-class MemoryConfig(BaseModel):
-    role_prefix: RolePrefix | None = None
-    window: MemoryWindowConfig | None = None
-    query_prompt_template: str | None = None
-    mode: MemoryMode = MemoryMode.CONVERSATION
-```
-
-**Mode Behavior:**
-
-| Mode           | Memory Class          | Scope                    | Availability  |
-| -------------- | --------------------- | ------------------------ | ------------- |
-| `conversation` | TokenBufferMemory     | Entire conversation      | All app modes |
-| `node`         | NodeTokenBufferMemory | Per-node in conversation | Chatflow only |
-
-> When `mode=node` is used in a non-Chatflow context (no conversation_id), it falls back to no memory.
-
----
-
-## Comparison
-
-| Feature        | TokenBufferMemory        | NodeTokenBufferMemory              |
-| -------------- | ------------------------ | ---------------------------------- |
-| Scope          | Conversation             | Node within Conversation           |
-| Storage        | Database (Message table) | WorkflowNodeExecutionModel.outputs |
-| Thread Support | Yes                      | Yes                                |
-| File Support   | Yes (via MessageFile)    | Yes (via context serialization)    |
-| Token Limit    | Yes                      | Yes                                |
-| Use Case       | Standard chat apps       | Complex workflows                  |
-
----
-
-## Extending to Other Nodes
-
-Currently only **LLM Node** outputs `context` in its outputs. To enable node memory for other nodes:
-
-1. Add `outputs["context"] = self._build_context(prompt_messages, response)` in the node
-2. The `NodeTokenBufferMemory` will automatically pick it up
-
-Nodes that could potentially support this:
-- `question_classifier`
-- `parameter_extractor`
-- `agent`
-
----
-
-## Future Considerations
-
-1. **Cleanup**: Node memory lifecycle follows `WorkflowNodeExecutionModel`, which already has cleanup mechanisms
-2. **Compression**: For very long conversations, consider summarization strategies
-3. **Extension**: Other nodes may benefit from node-level memory

api/core/memory/__init__.py

@@ -1,11 +0,0 @@
-from core.memory.base import BaseMemory
-from core.memory.node_token_buffer_memory import (
-    NodeTokenBufferMemory,
-)
-from core.memory.token_buffer_memory import TokenBufferMemory
-
-__all__ = [
-    "BaseMemory",
-    "NodeTokenBufferMemory",
-    "TokenBufferMemory",
-]

api/core/memory/base.py

@@ -1,83 +0,0 @@
-"""
-Base memory interfaces and types.
-
-This module defines the common protocol for memory implementations.
-"""
-
-from abc import ABC, abstractmethod
-from collections.abc import Sequence
-
-from core.model_runtime.entities import ImagePromptMessageContent, PromptMessage
-
-
-class BaseMemory(ABC):
-    """
-    Abstract base class for memory implementations.
-
-    Provides a common interface for both conversation-level and node-level memory.
-    """
-
-    @abstractmethod
-    def get_history_prompt_messages(
-        self,
-        *,
-        max_token_limit: int = 2000,
-        message_limit: int | None = None,
-    ) -> Sequence[PromptMessage]:
-        """
-        Get history prompt messages.
-
-        :param max_token_limit: Maximum tokens for history
-        :param message_limit: Maximum number of messages
-        :return: Sequence of PromptMessage for LLM context
-        """
-        pass
-
-    def get_history_prompt_text(
-        self,
-        human_prefix: str = "Human",
-        ai_prefix: str = "Assistant",
-        max_token_limit: int = 2000,
-        message_limit: int | None = None,
-    ) -> str:
-        """
-        Get history prompt as formatted text.
-
-        :param human_prefix: Prefix for human messages
-        :param ai_prefix: Prefix for assistant messages
-        :param max_token_limit: Maximum tokens for history
-        :param message_limit: Maximum number of messages
-        :return: Formatted history text
-        """
-        from core.model_runtime.entities import (
-            PromptMessageRole,
-            TextPromptMessageContent,
-        )
-
-        prompt_messages = self.get_history_prompt_messages(
-            max_token_limit=max_token_limit,
-            message_limit=message_limit,
-        )
-
-        string_messages = []
-        for m in prompt_messages:
-            if m.role == PromptMessageRole.USER:
-                role = human_prefix
-            elif m.role == PromptMessageRole.ASSISTANT:
-                role = ai_prefix
-            else:
-                continue
-
-            if isinstance(m.content, list):
-                inner_msg = ""
-                for content in m.content:
-                    if isinstance(content, TextPromptMessageContent):
-                        inner_msg += f"{content.data}\n"
-                    elif isinstance(content, ImagePromptMessageContent):
-                        inner_msg += "[image]\n"
-                string_messages.append(f"{role}: {inner_msg.strip()}")
-            else:
-                message = f"{role}: {m.content}"
-                string_messages.append(message)
-
-        return "\n".join(string_messages)

api/core/memory/node_token_buffer_memory.py

@@ -1,197 +0,0 @@
-"""
-Node-level Token Buffer Memory for Chatflow.
-
-This module provides node-scoped memory within a conversation.
-Each LLM node in a workflow can maintain its own independent conversation history.
-
-Note: This is only available in Chatflow (advanced-chat mode) because it requires
-both conversation_id and node_id.
-
-Design:
-- History is read directly from WorkflowNodeExecutionModel.outputs["context"]
-- No separate storage needed - the context is already saved during node execution
-- Thread tracking leverages Message table's parent_message_id structure
-"""
-
-import logging
-from collections.abc import Sequence
-from typing import cast
-
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-from core.file import file_manager
-from core.memory.base import BaseMemory
-from core.model_manager import ModelInstance
-from core.model_runtime.entities import (
-    AssistantPromptMessage,
-    MultiModalPromptMessageContent,
-    PromptMessage,
-    PromptMessageRole,
-    SystemPromptMessage,
-    ToolPromptMessage,
-    UserPromptMessage,
-)
-from core.model_runtime.entities.message_entities import PromptMessageContentUnionTypes
-from core.prompt.utils.extract_thread_messages import extract_thread_messages
-from extensions.ext_database import db
-from models.model import Message
-from models.workflow import WorkflowNodeExecutionModel
-
-logger = logging.getLogger(__name__)
-
-
-class NodeTokenBufferMemory(BaseMemory):
-    """
-    Node-level Token Buffer Memory.
-
-    Provides node-scoped memory within a conversation. Each LLM node can maintain
-    its own independent conversation history.
-
-    Key design: History is read directly from WorkflowNodeExecutionModel.outputs["context"],
-    which is already saved during node execution. No separate storage needed.
-    """
-
-    def __init__(
-        self,
-        app_id: str,
-        conversation_id: str,
-        node_id: str,
-        tenant_id: str,
-        model_instance: ModelInstance,
-    ):
-        self.app_id = app_id
-        self.conversation_id = conversation_id
-        self.node_id = node_id
-        self.tenant_id = tenant_id
-        self.model_instance = model_instance
-
-    def _get_thread_workflow_run_ids(self) -> list[str]:
-        """
-        Get workflow_run_ids for the current thread by querying Message table.
-        Returns workflow_run_ids in chronological order (oldest first).
-        """
-        with Session(db.engine, expire_on_commit=False) as session:
-            stmt = (
-                select(Message)
-                .where(Message.conversation_id == self.conversation_id)
-                .order_by(Message.created_at.desc())
-                .limit(500)
-            )
-            messages = list(session.scalars(stmt).all())
-
-        if not messages:
-            return []
-
-        # Extract thread messages using existing logic
-        thread_messages = extract_thread_messages(messages)
-
-        # For newly created message, its answer is temporarily empty, skip it
-        if thread_messages and not thread_messages[0].answer and thread_messages[0].answer_tokens == 0:
-            thread_messages.pop(0)
-
-        # Reverse to get chronological order, extract workflow_run_ids
-        return [msg.workflow_run_id for msg in reversed(thread_messages) if msg.workflow_run_id]
-
-    def _deserialize_prompt_message(self, msg_dict: dict) -> PromptMessage:
-        """Deserialize a dict to PromptMessage based on role."""
-        role = msg_dict.get("role")
-        if role in (PromptMessageRole.USER, "user"):
-            return UserPromptMessage.model_validate(msg_dict)
-        elif role in (PromptMessageRole.ASSISTANT, "assistant"):
-            return AssistantPromptMessage.model_validate(msg_dict)
-        elif role in (PromptMessageRole.SYSTEM, "system"):
-            return SystemPromptMessage.model_validate(msg_dict)
-        elif role in (PromptMessageRole.TOOL, "tool"):
-            return ToolPromptMessage.model_validate(msg_dict)
-        else:
-            return PromptMessage.model_validate(msg_dict)
-
-    def _deserialize_context(self, context_data: list[dict]) -> list[PromptMessage]:
-        """Deserialize context data from outputs to list of PromptMessage."""
-        messages = []
-        for msg_dict in context_data:
-            try:
-                msg = self._deserialize_prompt_message(msg_dict)
-                msg = self._restore_multimodal_content(msg)
-                messages.append(msg)
-            except Exception as e:
-                logger.warning("Failed to deserialize prompt message: %s", e)
-        return messages
-
-    def _restore_multimodal_content(self, message: PromptMessage) -> PromptMessage:
-        """
-        Restore multimodal content (base64 or url) from file_ref.
-
-        When context is saved, base64_data is cleared to save storage space.
-        This method restores the content by parsing file_ref (format: "method:id_or_url").
-        """
-        content = message.content
-        if content is None or isinstance(content, str):
-            return message
-
-        # Process list content, restoring multimodal data from file references
-        restored_content: list[PromptMessageContentUnionTypes] = []
-        for item in content:
-            if isinstance(item, MultiModalPromptMessageContent):
-                # restore_multimodal_content preserves the concrete subclass type
-                restored_item = file_manager.restore_multimodal_content(item)
-                restored_content.append(cast(PromptMessageContentUnionTypes, restored_item))
-            else:
-                restored_content.append(item)
-
-        return message.model_copy(update={"content": restored_content})
-
-    def get_history_prompt_messages(
-        self,
-        *,
-        max_token_limit: int = 2000,
-        message_limit: int | None = None,
-    ) -> Sequence[PromptMessage]:
-        """
-        Retrieve history as PromptMessage sequence.
-        History is read directly from the last completed node execution's outputs["context"].
-        """
-        _ = message_limit  # unused, kept for interface compatibility
-
-        thread_workflow_run_ids = self._get_thread_workflow_run_ids()
-        if not thread_workflow_run_ids:
-            return []
-
-        # Get the last completed workflow_run_id (contains accumulated context)
-        last_run_id = thread_workflow_run_ids[-1]
-
-        with Session(db.engine, expire_on_commit=False) as session:
-            stmt = select(WorkflowNodeExecutionModel).where(
-                WorkflowNodeExecutionModel.workflow_run_id == last_run_id,
-                WorkflowNodeExecutionModel.node_id == self.node_id,
-                WorkflowNodeExecutionModel.status == "succeeded",
-            )
-            execution = session.scalars(stmt).first()
-
-            if not execution:
-                return []
-
-            outputs = execution.outputs_dict
-            if not outputs:
-                return []
-
-            context_data = outputs.get("context")
-
-        if not context_data or not isinstance(context_data, list):
-            return []
-
-        prompt_messages = self._deserialize_context(context_data)
-        if not prompt_messages:
-            return []
-
-        # Truncate by token limit
-        try:
-            current_tokens = self.model_instance.get_llm_num_tokens(prompt_messages)
-            while current_tokens > max_token_limit and len(prompt_messages) > 1:
-                prompt_messages.pop(0)
-                current_tokens = self.model_instance.get_llm_num_tokens(prompt_messages)
-        except Exception as e:
-            logger.warning("Failed to count tokens for truncation: %s", e)
-
-        return prompt_messages

api/core/memory/token_buffer_memory.py

@@ -5,12 +5,12 @@ from sqlalchemy.orm import sessionmaker
 
 from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
 from core.file import file_manager
-from core.memory.base import BaseMemory
 from core.model_manager import ModelInstance
 from core.model_runtime.entities import (
     AssistantPromptMessage,
     ImagePromptMessageContent,
     PromptMessage,
+    PromptMessageRole,
     TextPromptMessageContent,
     UserPromptMessage,
 )
@@ -24,7 +24,7 @@ from repositories.api_workflow_run_repository import APIWorkflowRunRepository
 from repositories.factory import DifyAPIRepositoryFactory
 
 
-class TokenBufferMemory(BaseMemory):
+class TokenBufferMemory:
     def __init__(
         self,
         conversation: Conversation,
@@ -115,14 +115,10 @@ class TokenBufferMemory(BaseMemory):
                 return AssistantPromptMessage(content=prompt_message_contents)
 
     def get_history_prompt_messages(
-        self,
-        *,
-        max_token_limit: int = 2000,
-        message_limit: int | None = None,
+        self, max_token_limit: int = 2000, message_limit: int | None = None
     ) -> Sequence[PromptMessage]:
         """
         Get history prompt messages.
-
         :param max_token_limit: max token limit
         :param message_limit: message limit
         """
@@ -204,3 +200,44 @@ class TokenBufferMemory(BaseMemory):
                 curr_message_tokens = self.model_instance.get_llm_num_tokens(prompt_messages)
 
         return prompt_messages
+
+    def get_history_prompt_text(
+        self,
+        human_prefix: str = "Human",
+        ai_prefix: str = "Assistant",
+        max_token_limit: int = 2000,
+        message_limit: int | None = None,
+    ) -> str:
+        """
+        Get history prompt text.
+        :param human_prefix: human prefix
+        :param ai_prefix: ai prefix
+        :param max_token_limit: max token limit
+        :param message_limit: message limit
+        :return:
+        """
+        prompt_messages = self.get_history_prompt_messages(max_token_limit=max_token_limit, message_limit=message_limit)
+
+        string_messages = []
+        for m in prompt_messages:
+            if m.role == PromptMessageRole.USER:
+                role = human_prefix
+            elif m.role == PromptMessageRole.ASSISTANT:
+                role = ai_prefix
+            else:
+                continue
+
+            if isinstance(m.content, list):
+                inner_msg = ""
+                for content in m.content:
+                    if isinstance(content, TextPromptMessageContent):
+                        inner_msg += f"{content.data}\n"
+                    elif isinstance(content, ImagePromptMessageContent):
+                        inner_msg += "[image]\n"
+
+                string_messages.append(f"{role}: {inner_msg.strip()}")
+            else:
+                message = f"{role}: {m.content}"
+                string_messages.append(message)
+
+        return "\n".join(string_messages)

api/core/model_runtime/entities/message_entities.py

@@ -91,9 +91,6 @@ class MultiModalPromptMessageContent(PromptMessageContent):
     mime_type: str = Field(default=..., description="the mime type of multi-modal file")
     filename: str = Field(default="", description="the filename of multi-modal file")
 
-    # File reference for context restoration, format: "transfer_method:related_id" or "remote:url"
-    file_ref: str | None = Field(default=None, description="Encoded file reference for restoration")
-
     @property
     def data(self):
         return self.url or f"data:{self.mime_type};base64,{self.base64_data}"
@@ -279,5 +276,7 @@ class ToolPromptMessage(PromptMessage):
 
         :return: True if prompt message is empty, False otherwise
         """
-        # ToolPromptMessage is not empty if it has content OR has a tool_call_id
-        return super().is_empty() and not self.tool_call_id
+        if not super().is_empty() and not self.tool_call_id:
+            return False
+
+        return True

api/core/plugin/impl/base.py

@@ -320,18 +320,17 @@ class BasePluginClient:
             case PluginInvokeError.__name__:
                 error_object = json.loads(message)
                 invoke_error_type = error_object.get("error_type")
-                args = error_object.get("args")
                 match invoke_error_type:
                     case InvokeRateLimitError.__name__:
-                        raise InvokeRateLimitError(description=args.get("description"))
+                        raise InvokeRateLimitError(description=error_object.get("message"))
                     case InvokeAuthorizationError.__name__:
-                        raise InvokeAuthorizationError(description=args.get("description"))
+                        raise InvokeAuthorizationError(description=error_object.get("message"))
                     case InvokeBadRequestError.__name__:
-                        raise InvokeBadRequestError(description=args.get("description"))
+                        raise InvokeBadRequestError(description=error_object.get("message"))
                     case InvokeConnectionError.__name__:
-                        raise InvokeConnectionError(description=args.get("description"))
+                        raise InvokeConnectionError(description=error_object.get("message"))
                     case InvokeServerUnavailableError.__name__:
-                        raise InvokeServerUnavailableError(description=args.get("description"))
+                        raise InvokeServerUnavailableError(description=error_object.get("message"))
                     case CredentialsValidateFailedError.__name__:
                         raise CredentialsValidateFailedError(error_object.get("message"))
                     case EndpointSetupFailedError.__name__:
@@ -339,11 +338,11 @@ class BasePluginClient:
                     case TriggerProviderCredentialValidationError.__name__:
                         raise TriggerProviderCredentialValidationError(error_object.get("message"))
                     case TriggerPluginInvokeError.__name__:
-                        raise TriggerPluginInvokeError(description=error_object.get("description"))
+                        raise TriggerPluginInvokeError(description=error_object.get("message"))
                     case TriggerInvokeError.__name__:
                         raise TriggerInvokeError(error_object.get("message"))
                     case EventIgnoreError.__name__:
-                        raise EventIgnoreError(description=error_object.get("description"))
+                        raise EventIgnoreError(description=error_object.get("message"))
                     case _:
                         raise PluginInvokeError(description=message)
             case PluginDaemonInternalServerError.__name__:

api/core/prompt/advanced_prompt_transform.py

@@ -5,7 +5,7 @@ from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEnti
 from core.file import file_manager
 from core.file.models import File
 from core.helper.code_executor.jinja2.jinja2_formatter import Jinja2Formatter
-from core.memory.base import BaseMemory
+from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_runtime.entities import (
     AssistantPromptMessage,
     PromptMessage,
@@ -43,7 +43,7 @@ class AdvancedPromptTransform(PromptTransform):
         files: Sequence[File],
         context: str | None,
         memory_config: MemoryConfig | None,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         model_config: ModelConfigWithCredentialsEntity,
         image_detail_config: ImagePromptMessageContent.DETAIL | None = None,
     ) -> list[PromptMessage]:
@@ -84,7 +84,7 @@ class AdvancedPromptTransform(PromptTransform):
         files: Sequence[File],
         context: str | None,
         memory_config: MemoryConfig | None,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         model_config: ModelConfigWithCredentialsEntity,
         image_detail_config: ImagePromptMessageContent.DETAIL | None = None,
     ) -> list[PromptMessage]:
@@ -145,7 +145,7 @@ class AdvancedPromptTransform(PromptTransform):
         files: Sequence[File],
         context: str | None,
         memory_config: MemoryConfig | None,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         model_config: ModelConfigWithCredentialsEntity,
         image_detail_config: ImagePromptMessageContent.DETAIL | None = None,
     ) -> list[PromptMessage]:
@@ -270,7 +270,7 @@ class AdvancedPromptTransform(PromptTransform):
 
     def _set_histories_variable(
         self,
-        memory: BaseMemory,
+        memory: TokenBufferMemory,
         memory_config: MemoryConfig,
         raw_prompt: str,
         role_prefix: MemoryConfig.RolePrefix,

api/core/prompt/entities/advanced_prompt_entities.py

@@ -1,4 +1,3 @@
-from enum import StrEnum
 from typing import Literal
 
 from pydantic import BaseModel
@@ -6,13 +5,6 @@ from pydantic import BaseModel
 from core.model_runtime.entities.message_entities import PromptMessageRole
 
 
-class MemoryMode(StrEnum):
-    """Memory mode for LLM nodes."""
-
-    CONVERSATION = "conversation"  # Use TokenBufferMemory (default, existing behavior)
-    NODE = "node"  # Use NodeTokenBufferMemory (Chatflow only)
-
-
 class ChatModelMessage(BaseModel):
     """
     Chat Message.
@@ -56,4 +48,3 @@ class MemoryConfig(BaseModel):
     role_prefix: RolePrefix | None = None
     window: WindowConfig
     query_prompt_template: str | None = None
-    mode: MemoryMode = MemoryMode.CONVERSATION

api/core/prompt/prompt_transform.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
-from core.memory.base import BaseMemory
+from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance
 from core.model_runtime.entities.message_entities import PromptMessage
 from core.model_runtime.entities.model_entities import ModelPropertyKey
@@ -11,7 +11,7 @@ from core.prompt.entities.advanced_prompt_entities import MemoryConfig
 class PromptTransform:
     def _append_chat_histories(
         self,
-        memory: BaseMemory,
+        memory: TokenBufferMemory,
         memory_config: MemoryConfig,
         prompt_messages: list[PromptMessage],
         model_config: ModelConfigWithCredentialsEntity,
@@ -52,7 +52,7 @@ class PromptTransform:
 
     def _get_history_messages_from_memory(
         self,
-        memory: BaseMemory,
+        memory: TokenBufferMemory,
         memory_config: MemoryConfig,
         max_token_limit: int,
         human_prefix: str | None = None,
@@ -73,7 +73,7 @@ class PromptTransform:
         return memory.get_history_prompt_text(**kwargs)
 
     def _get_history_messages_list_from_memory(
-        self, memory: BaseMemory, memory_config: MemoryConfig, max_token_limit: int
+        self, memory: TokenBufferMemory, memory_config: MemoryConfig, max_token_limit: int
     ) -> list[PromptMessage]:
         """Get memory messages."""
         return list(

api/core/tools/tool_manager.py

@@ -1047,8 +1047,6 @@ class ToolManager:
                         continue
                     tool_input = ToolNodeData.ToolInput.model_validate(tool_configurations.get(parameter.name, {}))
                     if tool_input.type == "variable":
-                        if not isinstance(tool_input.value, list):
-                            raise ToolParameterError(f"Invalid variable selector for {parameter.name}")
                         variable = variable_pool.get(tool_input.value)
                         if variable is None:
                             raise ToolParameterError(f"Variable {tool_input.value} does not exist")
@@ -1058,11 +1056,6 @@ class ToolManager:
                     elif tool_input.type == "mixed":
                         segment_group = variable_pool.convert_template(str(tool_input.value))
                         parameter_value = segment_group.text
-                    elif tool_input.type == "mention":
-                        # Mention type not supported in agent mode
-                        raise ToolParameterError(
-                            f"Mention type not supported in agent for parameter '{parameter.name}'"
-                        )
                     else:
                         raise ToolParameterError(f"Unknown tool input type '{tool_input.type}'")
                     runtime_parameters[parameter.name] = parameter_value

api/core/variables/__init__.py

@@ -4,7 +4,6 @@ from .segments import (
     ArrayFileSegment,
     ArrayNumberSegment,
     ArrayObjectSegment,
-    ArrayPromptMessageSegment,
     ArraySegment,
     ArrayStringSegment,
     FileSegment,
@@ -21,7 +20,6 @@ from .variables import (
     ArrayFileVariable,
     ArrayNumberVariable,
     ArrayObjectVariable,
-    ArrayPromptMessageVariable,
     ArrayStringVariable,
     ArrayVariable,
     FileVariable,
@@ -44,8 +42,6 @@ __all__ = [
     "ArrayNumberVariable",
     "ArrayObjectSegment",
     "ArrayObjectVariable",
-    "ArrayPromptMessageSegment",
-    "ArrayPromptMessageVariable",
     "ArraySegment",
     "ArrayStringSegment",
     "ArrayStringVariable",

api/core/variables/segments.py

@@ -6,7 +6,6 @@ from typing import Annotated, Any, TypeAlias
 from pydantic import BaseModel, ConfigDict, Discriminator, Tag, field_validator
 
 from core.file import File
-from core.model_runtime.entities import PromptMessage
 
 from .types import SegmentType
 
@@ -209,15 +208,6 @@ class ArrayBooleanSegment(ArraySegment):
     value: Sequence[bool]
 
 
-class ArrayPromptMessageSegment(ArraySegment):
-    value_type: SegmentType = SegmentType.ARRAY_PROMPT_MESSAGE
-    value: Sequence[PromptMessage]
-
-    def to_object(self):
-        """Convert to JSON-serializable format for database storage and frontend."""
-        return [msg.model_dump() for msg in self.value]
-
-
 def get_segment_discriminator(v: Any) -> SegmentType | None:
     if isinstance(v, Segment):
         return v.value_type
@@ -258,7 +248,6 @@ SegmentUnion: TypeAlias = Annotated[
         | Annotated[ArrayObjectSegment, Tag(SegmentType.ARRAY_OBJECT)]
         | Annotated[ArrayFileSegment, Tag(SegmentType.ARRAY_FILE)]
         | Annotated[ArrayBooleanSegment, Tag(SegmentType.ARRAY_BOOLEAN)]
-        | Annotated[ArrayPromptMessageSegment, Tag(SegmentType.ARRAY_PROMPT_MESSAGE)]
     ),
     Discriminator(get_segment_discriminator),
 ]

api/core/variables/types.py

@@ -45,7 +45,6 @@ class SegmentType(StrEnum):
     ARRAY_OBJECT = "array[object]"
     ARRAY_FILE = "array[file]"
     ARRAY_BOOLEAN = "array[boolean]"
-    ARRAY_PROMPT_MESSAGE = "array[message]"
 
     NONE = "none"
 

api/core/variables/utils.py

@@ -3,10 +3,8 @@ from typing import Any
 
 import orjson
 
-from core.model_runtime.entities import PromptMessage
-
 from .segment_group import SegmentGroup
-from .segments import ArrayFileSegment, ArrayPromptMessageSegment, FileSegment, Segment
+from .segments import ArrayFileSegment, FileSegment, Segment
 
 
 def to_selector(node_id: str, name: str, paths: Iterable[str] = ()) -> Sequence[str]:
@@ -18,7 +16,7 @@ def to_selector(node_id: str, name: str, paths: Iterable[str] = ()) -> Sequence[
 
 def segment_orjson_default(o: Any):
     """Default function for orjson serialization of Segment types"""
-    if isinstance(o, (ArrayFileSegment, ArrayPromptMessageSegment)):
+    if isinstance(o, ArrayFileSegment):
         return [v.model_dump() for v in o.value]
     elif isinstance(o, FileSegment):
         return o.value.model_dump()
@@ -26,8 +24,6 @@ def segment_orjson_default(o: Any):
         return [segment_orjson_default(seg) for seg in o.value]
     elif isinstance(o, Segment):
         return o.value
-    elif isinstance(o, PromptMessage):
-        return o.model_dump()
     raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
 
 

api/core/variables/variables.py

@@ -12,7 +12,6 @@ from .segments import (
     ArrayFileSegment,
     ArrayNumberSegment,
     ArrayObjectSegment,
-    ArrayPromptMessageSegment,
     ArraySegment,
     ArrayStringSegment,
     BooleanSegment,
@@ -111,10 +110,6 @@ class ArrayBooleanVariable(ArrayBooleanSegment, ArrayVariable):
     pass
 
 
-class ArrayPromptMessageVariable(ArrayPromptMessageSegment, ArrayVariable):
-    pass
-
-
 class RAGPipelineVariable(BaseModel):
     belong_to_node_id: str = Field(description="belong to which node id, shared means public")
     type: str = Field(description="variable type, text-input, paragraph, select, number,  file, file-list")
@@ -165,7 +160,6 @@ Variable: TypeAlias = Annotated[
         | Annotated[ArrayObjectVariable, Tag(SegmentType.ARRAY_OBJECT)]
         | Annotated[ArrayFileVariable, Tag(SegmentType.ARRAY_FILE)]
         | Annotated[ArrayBooleanVariable, Tag(SegmentType.ARRAY_BOOLEAN)]
-        | Annotated[ArrayPromptMessageVariable, Tag(SegmentType.ARRAY_PROMPT_MESSAGE)]
         | Annotated[SecretVariable, Tag(SegmentType.SECRET)]
     ),
     Discriminator(get_segment_discriminator),

api/core/workflow/enums.py

@@ -63,7 +63,6 @@ class NodeType(StrEnum):
     TRIGGER_SCHEDULE = "trigger-schedule"
     TRIGGER_PLUGIN = "trigger-plugin"
     HUMAN_INPUT = "human-input"
-    GROUP = "group"
 
     @property
     def is_trigger_node(self) -> bool:
@@ -253,7 +252,6 @@ class WorkflowNodeExecutionMetadataKey(StrEnum):
     LOOP_VARIABLE_MAP = "loop_variable_map"  # single loop variable output
     DATASOURCE_INFO = "datasource_info"
     COMPLETED_REASON = "completed_reason"  # completed reason for loop node
-    MENTION_PARENT_ID = "mention_parent_id"  # parent node id for extractor nodes
 
 
 class WorkflowNodeExecutionStatus(StrEnum):

api/core/workflow/graph/graph.py

@@ -307,14 +307,7 @@ class Graph:
         if not node_configs:
             raise ValueError("Graph must have at least one node")
 
-        # Filter out UI-only node types:
-        # - custom-note: top-level type (node_config.type == "custom-note")
-        # - group: data-level type (node_config.data.type == "group")
-        node_configs = [
-            node_config
-            for node_config in node_configs
-            if node_config.get("type", "") != "custom-note" and node_config.get("data", {}).get("type", "") != "group"
-        ]
+        node_configs = [node_config for node_config in node_configs if node_config.get("type", "") != "custom-note"]
 
         # Parse node configurations
         node_configs_map = cls._parse_node_configs(node_configs)

api/core/workflow/graph_engine/event_management/event_handlers.py

@@ -93,8 +93,8 @@ class EventHandler:
         Args:
             event: The event to handle
         """
-        # Events in loops, iterations, or extractor groups are always collected
-        if event.in_loop_id or event.in_iteration_id or event.in_mention_parent_id:
+        # Events in loops or iterations are always collected
+        if event.in_loop_id or event.in_iteration_id:
             self._event_collector.collect(event)
             return
         return self._dispatch(event)
@@ -125,11 +125,6 @@ class EventHandler:
         Args:
             event: The node started event
         """
-        # Check if this is an extractor node (has parent_node_id)
-        if self._is_extractor_node(event.node_id):
-            self._handle_extractor_node_started(event)
-            return
-
         # Track execution in domain model
         node_execution = self._graph_execution.get_or_create_node_execution(event.node_id)
         is_initial_attempt = node_execution.retry_count == 0
@@ -169,11 +164,6 @@ class EventHandler:
         Args:
             event: The node succeeded event
         """
-        # Check if this is an extractor node (has parent_node_id)
-        if self._is_extractor_node(event.node_id):
-            self._handle_extractor_node_success(event)
-            return
-
         # Update domain model
         node_execution = self._graph_execution.get_or_create_node_execution(event.node_id)
         node_execution.mark_taken()
@@ -236,11 +226,6 @@ class EventHandler:
         Args:
             event: The node failed event
         """
-        # Check if this is an extractor node (has parent_node_id)
-        if self._is_extractor_node(event.node_id):
-            self._handle_extractor_node_failed(event)
-            return
-
         # Update domain model
         node_execution = self._graph_execution.get_or_create_node_execution(event.node_id)
         node_execution.mark_failed(event.error)
@@ -360,57 +345,3 @@ class EventHandler:
                     self._graph_runtime_state.set_output("answer", value)
             else:
                 self._graph_runtime_state.set_output(key, value)
-
-    def _is_extractor_node(self, node_id: str) -> bool:
-        """
-        Check if node_id represents an extractor node (has parent_node_id).
-
-        Extractor nodes extract values from list[PromptMessage] for their parent node.
-        They have a parent_node_id field pointing to their parent node.
-        """
-        node = self._graph.nodes.get(node_id)
-        if node is None:
-            return False
-        return node.node_data.is_extractor_node
-
-    def _handle_extractor_node_started(self, event: NodeRunStartedEvent) -> None:
-        """
-        Handle extractor node started event.
-
-        Extractor nodes don't need full execution tracking, just collect the event.
-        """
-        # Track in response coordinator for stream ordering
-        self._response_coordinator.track_node_execution(event.node_id, event.id)
-
-        # Collect the event
-        self._event_collector.collect(event)
-
-    def _handle_extractor_node_success(self, event: NodeRunSucceededEvent) -> None:
-        """
-        Handle extractor node success event.
-
-        Extractor nodes need special handling:
-        - Store outputs in variable pool (for reference by other nodes)
-        - Accumulate token usage
-        - Collect the event for logging
-        - Do NOT process edges or enqueue next nodes (parent node handles that)
-        """
-        self._accumulate_node_usage(event.node_run_result.llm_usage)
-
-        # Store outputs in variable pool
-        self._store_node_outputs(event.node_id, event.node_run_result.outputs)
-
-        # Collect the event
-        self._event_collector.collect(event)
-
-    def _handle_extractor_node_failed(self, event: NodeRunFailedEvent) -> None:
-        """
-        Handle extractor node failed event.
-
-        Extractor node failures are collected for logging,
-        but the parent node is responsible for handling the error.
-        """
-        self._accumulate_node_usage(event.node_run_result.llm_usage)
-
-        # Collect the event for logging
-        self._event_collector.collect(event)

api/core/workflow/graph_engine/layers/persistence.py

@@ -68,7 +68,6 @@ class _NodeRuntimeSnapshot:
     predecessor_node_id: str | None
     iteration_id: str | None
     loop_id: str | None
-    mention_parent_id: str | None
     created_at: datetime
 
 
@@ -231,7 +230,6 @@ class WorkflowPersistenceLayer(GraphEngineLayer):
         metadata = {
             WorkflowNodeExecutionMetadataKey.ITERATION_ID: event.in_iteration_id,
             WorkflowNodeExecutionMetadataKey.LOOP_ID: event.in_loop_id,
-            WorkflowNodeExecutionMetadataKey.MENTION_PARENT_ID: event.in_mention_parent_id,
         }
 
         domain_execution = WorkflowNodeExecution(
@@ -258,7 +256,6 @@ class WorkflowPersistenceLayer(GraphEngineLayer):
             predecessor_node_id=event.predecessor_node_id,
             iteration_id=event.in_iteration_id,
             loop_id=event.in_loop_id,
-            mention_parent_id=event.in_mention_parent_id,
             created_at=event.start_at,
         )
         self._node_snapshots[event.id] = snapshot

api/core/workflow/graph_events/base.py

@@ -21,12 +21,6 @@ class GraphNodeEventBase(GraphEngineEvent):
     """iteration id if node is in iteration"""
     in_loop_id: str | None = None
     """loop id if node is in loop"""
-    in_mention_parent_id: str | None = None
-    """Parent node id if this is an extractor node event.
-    
-    When set, indicates this event belongs to an extractor node that
-    is extracting values for the specified parent node.
-    """
 
     # The version of the node, or "1" if not specified.
     node_version: str = "1"

api/core/workflow/nodes/agent/agent_node.py

@@ -12,20 +12,11 @@ from sqlalchemy.orm import Session
 from core.agent.entities import AgentToolEntity
 from core.agent.plugin_entities import AgentStrategyParameter
 from core.file import File, FileTransferMethod
-from core.memory.base import BaseMemory
-from core.memory.node_token_buffer_memory import NodeTokenBufferMemory
 from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance, ModelManager
 from core.model_runtime.entities.llm_entities import LLMUsage, LLMUsageMetadata
-from core.model_runtime.entities.message_entities import (
-    AssistantPromptMessage,
-    PromptMessage,
-    ToolPromptMessage,
-    UserPromptMessage,
-)
 from core.model_runtime.entities.model_entities import AIModelEntity, ModelType
 from core.model_runtime.utils.encoders import jsonable_encoder
-from core.prompt.entities.advanced_prompt_entities import MemoryMode
 from core.provider_manager import ProviderManager
 from core.tools.entities.tool_entities import (
     ToolIdentity,
@@ -145,9 +136,6 @@ class AgentNode(Node[AgentNodeData]):
             )
             return
 
-        # Fetch memory for node memory saving
-        memory = self._fetch_memory_for_save()
-
         try:
             yield from self._transform_message(
                 messages=message_stream,
@@ -161,7 +149,6 @@ class AgentNode(Node[AgentNodeData]):
                 node_type=self.node_type,
                 node_id=self._node_id,
                 node_execution_id=self.id,
-                memory=memory,
             )
         except PluginDaemonClientSideError as e:
             transform_error = AgentMessageTransformError(
@@ -408,20 +395,8 @@ class AgentNode(Node[AgentNodeData]):
             icon = None
         return icon
 
-    def _fetch_memory(self, model_instance: ModelInstance) -> BaseMemory | None:
-        """
-        Fetch memory based on configuration mode.
-
-        Returns TokenBufferMemory for conversation mode (default),
-        or NodeTokenBufferMemory for node mode (Chatflow only).
-        """
-        node_data = self.node_data
-        memory_config = node_data.memory
-
-        if not memory_config:
-            return None
-
-        # get conversation id (required for both modes in Chatflow)
+    def _fetch_memory(self, model_instance: ModelInstance) -> TokenBufferMemory | None:
+        # get conversation id
         conversation_id_variable = self.graph_runtime_state.variable_pool.get(
             ["sys", SystemVariableKey.CONVERSATION_ID]
         )
@@ -429,26 +404,16 @@ class AgentNode(Node[AgentNodeData]):
             return None
         conversation_id = conversation_id_variable.value
 
-        # Return appropriate memory type based on mode
-        if memory_config.mode == MemoryMode.NODE:
-            # Node-level memory (Chatflow only)
-            return NodeTokenBufferMemory(
-                app_id=self.app_id,
-                conversation_id=conversation_id,
-                node_id=self._node_id,
-                tenant_id=self.tenant_id,
-                model_instance=model_instance,
-            )
-        else:
-            # Conversation-level memory (default)
-            with Session(db.engine, expire_on_commit=False) as session:
-                stmt = select(Conversation).where(
-                    Conversation.app_id == self.app_id, Conversation.id == conversation_id
-                )
-                conversation = session.scalar(stmt)
-                if not conversation:
-                    return None
-            return TokenBufferMemory(conversation=conversation, model_instance=model_instance)
+        with Session(db.engine, expire_on_commit=False) as session:
+            stmt = select(Conversation).where(Conversation.app_id == self.app_id, Conversation.id == conversation_id)
+            conversation = session.scalar(stmt)
+
+            if not conversation:
+                return None
+
+        memory = TokenBufferMemory(conversation=conversation, model_instance=model_instance)
+
+        return memory
 
     def _fetch_model(self, value: dict[str, Any]) -> tuple[ModelInstance, AIModelEntity | None]:
         provider_manager = ProviderManager()
@@ -492,136 +457,6 @@ class AgentNode(Node[AgentNodeData]):
         else:
             return [tool for tool in tools if tool.get("type") != ToolProviderType.MCP]
 
-    def _fetch_memory_for_save(self) -> BaseMemory | None:
-        """
-        Fetch memory instance for saving node memory.
-        This is a simplified version that doesn't require model_instance.
-        """
-        from core.model_manager import ModelManager
-        from core.model_runtime.entities.model_entities import ModelType
-
-        node_data = self.node_data
-        if not node_data.memory:
-            return None
-
-        # Get conversation_id
-        conversation_id_var = self.graph_runtime_state.variable_pool.get(["sys", SystemVariableKey.CONVERSATION_ID])
-        if not isinstance(conversation_id_var, StringSegment):
-            return None
-        conversation_id = conversation_id_var.value
-
-        # Return appropriate memory type based on mode
-        if node_data.memory.mode == MemoryMode.NODE:
-            # For node memory, we need a model_instance for token counting
-            # Use a simple default model for this purpose
-            try:
-                model_instance = ModelManager().get_default_model_instance(
-                    tenant_id=self.tenant_id,
-                    model_type=ModelType.LLM,
-                )
-            except Exception:
-                return None
-
-            return NodeTokenBufferMemory(
-                app_id=self.app_id,
-                conversation_id=conversation_id,
-                node_id=self._node_id,
-                tenant_id=self.tenant_id,
-                model_instance=model_instance,
-            )
-        else:
-            # Conversation-level memory doesn't need saving here
-            return None
-
-    def _build_context(
-        self,
-        parameters_for_log: dict[str, Any],
-        user_query: str,
-        assistant_response: str,
-        agent_logs: list[AgentLogEvent],
-    ) -> list[PromptMessage]:
-        """
-        Build context from user query, tool calls, and assistant response.
-        Format: user -> assistant(with tool_calls) -> tool -> assistant
-
-        The context includes:
-        - Current user query (always present, may be empty)
-        - Assistant message with tool_calls (if tools were called)
-        - Tool results
-        - Assistant's final response
-        """
-        context_messages: list[PromptMessage] = []
-
-        # Always add user query (even if empty, to maintain conversation structure)
-        context_messages.append(UserPromptMessage(content=user_query or ""))
-
-        # Extract actual tool calls from agent logs
-        # Only include logs with label starting with "CALL " - these are real tool invocations
-        tool_calls: list[AssistantPromptMessage.ToolCall] = []
-        tool_results: list[tuple[str, str, str]] = []  # (tool_call_id, tool_name, result)
-
-        for log in agent_logs:
-            if log.status == "success" and log.label and log.label.startswith("CALL "):
-                # Extract tool name from label (format: "CALL tool_name")
-                tool_name = log.label[5:]  # Remove "CALL " prefix
-                tool_call_id = log.message_id
-
-                # Parse tool response from data
-                data = log.data or {}
-                tool_response = ""
-
-                # Try to extract the actual tool response
-                if "tool_response" in data:
-                    tool_response = data["tool_response"]
-                elif "output" in data:
-                    tool_response = data["output"]
-                elif "result" in data:
-                    tool_response = data["result"]
-
-                if isinstance(tool_response, dict):
-                    tool_response = str(tool_response)
-
-                # Get tool input for arguments
-                tool_input = data.get("tool_call_input", {}) or data.get("input", {})
-                if isinstance(tool_input, dict):
-                    import json
-
-                    tool_input_str = json.dumps(tool_input, ensure_ascii=False)
-                else:
-                    tool_input_str = str(tool_input) if tool_input else ""
-
-                if tool_response:
-                    tool_calls.append(
-                        AssistantPromptMessage.ToolCall(
-                            id=tool_call_id,
-                            type="function",
-                            function=AssistantPromptMessage.ToolCall.ToolCallFunction(
-                                name=tool_name,
-                                arguments=tool_input_str,
-                            ),
-                        )
-                    )
-                    tool_results.append((tool_call_id, tool_name, str(tool_response)))
-
-        # Add assistant message with tool_calls if there were tool calls
-        if tool_calls:
-            context_messages.append(AssistantPromptMessage(content="", tool_calls=tool_calls))
-
-            # Add tool result messages
-            for tool_call_id, tool_name, result in tool_results:
-                context_messages.append(
-                    ToolPromptMessage(
-                        content=result,
-                        tool_call_id=tool_call_id,
-                        name=tool_name,
-                    )
-                )
-
-        # Add final assistant response
-        context_messages.append(AssistantPromptMessage(content=assistant_response))
-
-        return context_messages
-
     def _transform_message(
         self,
         messages: Generator[ToolInvokeMessage, None, None],
@@ -632,7 +467,6 @@ class AgentNode(Node[AgentNodeData]):
         node_type: NodeType,
         node_id: str,
         node_execution_id: str,
-        memory: BaseMemory | None = None,
     ) -> Generator[NodeEventBase, None, None]:
         """
         Convert ToolInvokeMessages into tuple[plain_text, files]
@@ -877,12 +711,6 @@ class AgentNode(Node[AgentNodeData]):
                 is_final=True,
             )
 
-        # Get user query from parameters for building context
-        user_query = parameters_for_log.get("query", "")
-
-        # Build context from history, user query, tool calls and assistant response
-        context = self._build_context(parameters_for_log, user_query, text, agent_logs)
-
         yield StreamCompletedEvent(
             node_run_result=NodeRunResult(
                 status=WorkflowNodeExecutionStatus.SUCCEEDED,
@@ -891,7 +719,6 @@ class AgentNode(Node[AgentNodeData]):
                     "usage": jsonable_encoder(llm_usage),
                     "files": ArrayFileSegment(value=files),
                     "json": json_output,
-                    "context": context,
                     **variables,
                 },
                 metadata={

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

@@ -1,10 +1,4 @@
-from .entities import (
-    BaseIterationNodeData,
-    BaseIterationState,
-    BaseLoopNodeData,
-    BaseLoopState,
-    BaseNodeData,
-)
+from .entities import BaseIterationNodeData, BaseIterationState, BaseLoopNodeData, BaseLoopState, BaseNodeData
 from .usage_tracking_mixin import LLMUsageTrackingMixin
 
 __all__ = [

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

@@ -175,16 +175,6 @@ class BaseNodeData(ABC, BaseModel):
     default_value: list[DefaultValue] | None = None
     retry_config: RetryConfig = RetryConfig()
 
-    # Parent node ID when this node is used as an extractor.
-    # If set, this node is an "attached" extractor node that extracts values
-    # from list[PromptMessage] for the parent node's parameters.
-    parent_node_id: str | None = None
-
-    @property
-    def is_extractor_node(self) -> bool:
-        """Check if this node is an extractor node (has parent_node_id)."""
-        return self.parent_node_id is not None
-
     @property
     def default_value_dict(self) -> dict[str, Any]:
         if self.default_value:

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

@@ -270,87 +270,10 @@ class Node(Generic[NodeDataT]):
         """Check if execution should be stopped."""
         return self.graph_runtime_state.stop_event.is_set()
 
-    def _find_extractor_node_configs(self) -> list[dict[str, Any]]:
-        """
-        Find all extractor node configurations that have parent_node_id == self._node_id.
-
-        Returns:
-            List of node configuration dicts for extractor nodes
-        """
-        nodes = self.graph_config.get("nodes", [])
-        extractor_configs = []
-        for node_config in nodes:
-            node_data = node_config.get("data", {})
-            if node_data.get("parent_node_id") == self._node_id:
-                extractor_configs.append(node_config)
-        return extractor_configs
-
-    def _execute_mention_nodes(self) -> Generator[GraphNodeEventBase, None, None]:
-        """
-        Execute all extractor nodes associated with this node.
-
-        Extractor nodes are nodes with parent_node_id == self._node_id.
-        They are executed before the main node to extract values from list[PromptMessage].
-        """
-        from core.workflow.nodes.node_mapping import LATEST_VERSION, NODE_TYPE_CLASSES_MAPPING
-
-        extractor_configs = self._find_extractor_node_configs()
-        logger.debug("[Extractor] Found %d extractor nodes for parent '%s'", len(extractor_configs), self._node_id)
-        if not extractor_configs:
-            return
-
-        for config in extractor_configs:
-            node_id = config.get("id")
-            node_data = config.get("data", {})
-            node_type_str = node_data.get("type")
-
-            if not node_id or not node_type_str:
-                continue
-
-            # Get node class
-            try:
-                node_type = NodeType(node_type_str)
-            except ValueError:
-                continue
-
-            node_mapping = NODE_TYPE_CLASSES_MAPPING.get(node_type)
-            if not node_mapping:
-                continue
-
-            node_version = str(node_data.get("version", "1"))
-            node_cls = node_mapping.get(node_version) or node_mapping.get(LATEST_VERSION)
-            if not node_cls:
-                continue
-
-            # Instantiate and execute the extractor node
-            extractor_node = node_cls(
-                id=node_id,
-                config=config,
-                graph_init_params=self._graph_init_params,
-                graph_runtime_state=self.graph_runtime_state,
-            )
-
-            # Execute and process extractor node events
-            for event in extractor_node.run():
-                # Tag event with parent node id for stream ordering and history tracking
-                if isinstance(event, GraphNodeEventBase):
-                    event.in_mention_parent_id = self._node_id
-
-                if isinstance(event, NodeRunSucceededEvent):
-                    # Store extractor node outputs in variable pool
-                    outputs: Mapping[str, Any] = event.node_run_result.outputs
-                    for variable_name, variable_value in outputs.items():
-                        self.graph_runtime_state.variable_pool.add((node_id, variable_name), variable_value)
-                if not isinstance(event, NodeRunStreamChunkEvent):
-                    yield event
-
     def run(self) -> Generator[GraphNodeEventBase, None, None]:
         execution_id = self.ensure_execution_id()
         self._start_at = naive_utc_now()
 
-        # Step 1: Execute associated extractor nodes before main node execution
-        yield from self._execute_mention_nodes()
-
         # Create and push start event with required fields
         start_event = NodeRunStartedEvent(
             id=execution_id,

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

@@ -1,7 +1,7 @@
 from collections.abc import Mapping, Sequence
-from typing import Annotated, Any, Literal, TypeAlias
+from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, Field, field_validator
 
 from core.model_runtime.entities import ImagePromptMessageContent, LLMMode
 from core.prompt.entities.advanced_prompt_entities import ChatModelMessage, CompletionModelPromptTemplate, MemoryConfig
@@ -58,28 +58,9 @@ class LLMNodeCompletionModelPromptTemplate(CompletionModelPromptTemplate):
     jinja2_text: str | None = None
 
 
-class PromptMessageContext(BaseModel):
-    """Context variable reference in prompt template.
-
-    YAML/JSON format: { "$context": ["node_id", "variable_name"] }
-    This will be expanded to list[PromptMessage] at runtime.
-    """
-
-    model_config = ConfigDict(populate_by_name=True)
-
-    value_selector: Sequence[str] = Field(alias="$context")
-
-
-# Union type for prompt template items (static message or context variable reference)
-PromptTemplateItem: TypeAlias = Annotated[
-    LLMNodeChatModelMessage | PromptMessageContext,
-    Field(discriminator=None),
-]
-
-
 class LLMNodeData(BaseNodeData):
     model: ModelConfig
-    prompt_template: Sequence[PromptTemplateItem] | LLMNodeCompletionModelPromptTemplate
+    prompt_template: Sequence[LLMNodeChatModelMessage] | LLMNodeCompletionModelPromptTemplate
     prompt_config: PromptConfig = Field(default_factory=PromptConfig)
     memory: MemoryConfig | None = None
     context: ContextConfig

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

@@ -8,20 +8,12 @@ from configs import dify_config
 from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
 from core.entities.provider_entities import ProviderQuotaType, QuotaUnit
 from core.file.models import File
-from core.memory import NodeTokenBufferMemory, TokenBufferMemory
-from core.memory.base import BaseMemory
+from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance, ModelManager
 from core.model_runtime.entities.llm_entities import LLMUsage
-from core.model_runtime.entities.message_entities import (
-    AssistantPromptMessage,
-    MultiModalPromptMessageContent,
-    PromptMessage,
-    PromptMessageContentUnionTypes,
-    PromptMessageRole,
-)
 from core.model_runtime.entities.model_entities import ModelType
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
-from core.prompt.entities.advanced_prompt_entities import MemoryConfig, MemoryMode
+from core.prompt.entities.advanced_prompt_entities import MemoryConfig
 from core.variables.segments import ArrayAnySegment, ArrayFileSegment, FileSegment, NoneSegment, StringSegment
 from core.workflow.enums import SystemVariableKey
 from core.workflow.nodes.llm.entities import ModelConfig
@@ -94,56 +86,25 @@ def fetch_files(variable_pool: VariablePool, selector: Sequence[str]) -> Sequenc
 
 
 def fetch_memory(
-    variable_pool: VariablePool,
-    app_id: str,
-    tenant_id: str,
-    node_data_memory: MemoryConfig | None,
-    model_instance: ModelInstance,
-    node_id: str = "",
-) -> BaseMemory | None:
-    """
-    Fetch memory based on configuration mode.
-
-    Returns TokenBufferMemory for conversation mode (default),
-    or NodeTokenBufferMemory for node mode (Chatflow only).
-
-    :param variable_pool: Variable pool containing system variables
-    :param app_id: Application ID
-    :param tenant_id: Tenant ID
-    :param node_data_memory: Memory configuration
-    :param model_instance: Model instance for token counting
-    :param node_id: Node ID in the workflow (required for node mode)
-    :return: Memory instance or None if not applicable
-    """
+    variable_pool: VariablePool, app_id: str, node_data_memory: MemoryConfig | None, model_instance: ModelInstance
+) -> TokenBufferMemory | None:
     if not node_data_memory:
         return None
 
-    # Get conversation_id from variable pool (required for both modes in Chatflow)
+    # get conversation id
     conversation_id_variable = variable_pool.get(["sys", SystemVariableKey.CONVERSATION_ID])
     if not isinstance(conversation_id_variable, StringSegment):
         return None
     conversation_id = conversation_id_variable.value
 
-    # Return appropriate memory type based on mode
-    if node_data_memory.mode == MemoryMode.NODE:
-        # Node-level memory (Chatflow only)
-        if not node_id:
+    with Session(db.engine, expire_on_commit=False) as session:
+        stmt = select(Conversation).where(Conversation.app_id == app_id, Conversation.id == conversation_id)
+        conversation = session.scalar(stmt)
+        if not conversation:
             return None
-        return NodeTokenBufferMemory(
-            app_id=app_id,
-            conversation_id=conversation_id,
-            node_id=node_id,
-            tenant_id=tenant_id,
-            model_instance=model_instance,
-        )
-    else:
-        # Conversation-level memory (default)
-        with Session(db.engine, expire_on_commit=False) as session:
-            stmt = select(Conversation).where(Conversation.app_id == app_id, Conversation.id == conversation_id)
-            conversation = session.scalar(stmt)
-            if not conversation:
-                return None
-        return TokenBufferMemory(conversation=conversation, model_instance=model_instance)
+
+    memory = TokenBufferMemory(conversation=conversation, model_instance=model_instance)
+    return memory
 
 
 def deduct_llm_quota(tenant_id: str, model_instance: ModelInstance, usage: LLMUsage):
@@ -209,87 +170,3 @@ def deduct_llm_quota(tenant_id: str, model_instance: ModelInstance, usage: LLMUs
                 )
                 session.execute(stmt)
                 session.commit()
-
-
-def build_context(
-    prompt_messages: Sequence[PromptMessage],
-    assistant_response: str,
-) -> list[PromptMessage]:
-    """
-    Build context from prompt messages and assistant response.
-    Excludes system messages and includes the current LLM response.
-    Returns list[PromptMessage] for use with ArrayPromptMessageSegment.
-
-    Note: Multi-modal content base64 data is truncated to avoid storing large data in context.
-    """
-    context_messages: list[PromptMessage] = [
-        _truncate_multimodal_content(m) for m in prompt_messages if m.role != PromptMessageRole.SYSTEM
-    ]
-    context_messages.append(AssistantPromptMessage(content=assistant_response))
-    return context_messages
-
-
-def _truncate_multimodal_content(message: PromptMessage) -> PromptMessage:
-    """
-    Truncate multi-modal content base64 data in a message to avoid storing large data.
-    Preserves the PromptMessage structure for ArrayPromptMessageSegment compatibility.
-
-    If file_ref is present, clears base64_data and url (they can be restored later).
-    Otherwise, truncates base64_data as fallback for legacy data.
-    """
-    content = message.content
-    if content is None or isinstance(content, str):
-        return message
-
-    # Process list content, handling multi-modal data based on file_ref availability
-    new_content: list[PromptMessageContentUnionTypes] = []
-    for item in content:
-        if isinstance(item, MultiModalPromptMessageContent):
-            if item.file_ref:
-                # Clear base64 and url, keep file_ref for later restoration
-                new_content.append(item.model_copy(update={"base64_data": "", "url": ""}))
-            else:
-                # Fallback: truncate base64_data if no file_ref (legacy data)
-                truncated_base64 = ""
-                if item.base64_data:
-                    truncated_base64 = item.base64_data[:10] + "...[TRUNCATED]..." + item.base64_data[-10:]
-                new_content.append(item.model_copy(update={"base64_data": truncated_base64}))
-        else:
-            new_content.append(item)
-
-    return message.model_copy(update={"content": new_content})
-
-
-def restore_multimodal_content_in_messages(messages: Sequence[PromptMessage]) -> list[PromptMessage]:
-    """
-    Restore multimodal content (base64 or url) in a list of PromptMessages.
-
-    When context is saved, base64_data is cleared to save storage space.
-    This function restores the content by parsing file_ref in each MultiModalPromptMessageContent.
-
-    Args:
-        messages: List of PromptMessages that may contain truncated multimodal content
-
-    Returns:
-        List of PromptMessages with restored multimodal content
-    """
-    from core.file import file_manager
-
-    return [_restore_message_content(msg, file_manager) for msg in messages]
-
-
-def _restore_message_content(message: PromptMessage, file_manager) -> PromptMessage:
-    """Restore multimodal content in a single PromptMessage."""
-    content = message.content
-    if content is None or isinstance(content, str):
-        return message
-
-    restored_content: list[PromptMessageContentUnionTypes] = []
-    for item in content:
-        if isinstance(item, MultiModalPromptMessageContent):
-            restored_item = file_manager.restore_multimodal_content(item)
-            restored_content.append(cast(PromptMessageContentUnionTypes, restored_item))
-        else:
-            restored_content.append(item)
-
-    return message.model_copy(update={"content": restored_content})

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

@@ -7,7 +7,7 @@ import logging
 import re
 import time
 from collections.abc import Generator, Mapping, Sequence
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal
 
 from sqlalchemy import select
 
@@ -16,7 +16,7 @@ from core.file import File, FileTransferMethod, FileType, file_manager
 from core.helper.code_executor import CodeExecutor, CodeLanguage
 from core.llm_generator.output_parser.errors import OutputParserError
 from core.llm_generator.output_parser.structured_output import invoke_llm_with_structured_output
-from core.memory.base import BaseMemory
+from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance, ModelManager
 from core.model_runtime.entities import (
     ImagePromptMessageContent,
@@ -51,7 +51,6 @@ from core.rag.entities.citation_metadata import RetrievalSourceMetadata
 from core.tools.signature import sign_upload_file
 from core.variables import (
     ArrayFileSegment,
-    ArrayPromptMessageSegment,
     ArraySegment,
     FileSegment,
     NoneSegment,
@@ -88,7 +87,6 @@ from .entities import (
     LLMNodeCompletionModelPromptTemplate,
     LLMNodeData,
     ModelConfig,
-    PromptMessageContext,
 )
 from .exc import (
     InvalidContextStructureError,
@@ -161,9 +159,8 @@ class LLMNode(Node[LLMNodeData]):
         variable_pool = self.graph_runtime_state.variable_pool
 
         try:
-            # Parse prompt template to separate static messages and context references
-            prompt_template = self.node_data.prompt_template
-            static_messages, context_refs, template_order = self._parse_prompt_template()
+            # init messages template
+            self.node_data.prompt_template = self._transform_chat_messages(self.node_data.prompt_template)
 
             # fetch variables and fetch values from variable pool
             inputs = self._fetch_inputs(node_data=self.node_data)
@@ -211,10 +208,8 @@ class LLMNode(Node[LLMNodeData]):
             memory = llm_utils.fetch_memory(
                 variable_pool=variable_pool,
                 app_id=self.app_id,
-                tenant_id=self.tenant_id,
                 node_data_memory=self.node_data.memory,
                 model_instance=model_instance,
-                node_id=self._node_id,
             )
 
             query: str | None = None
@@ -225,40 +220,21 @@ class LLMNode(Node[LLMNodeData]):
                 ):
                     query = query_variable.text
 
-            # Get prompt messages
-            prompt_messages: Sequence[PromptMessage]
-            stop: Sequence[str] | None
-            if isinstance(prompt_template, list) and context_refs:
-                prompt_messages, stop = self._build_prompt_messages_with_context(
-                    context_refs=context_refs,
-                    template_order=template_order,
-                    static_messages=static_messages,
-                    query=query,
-                    files=files,
-                    context=context,
-                    memory=memory,
-                    model_config=model_config,
-                    context_files=context_files,
-                )
-            else:
-                prompt_messages, stop = LLMNode.fetch_prompt_messages(
-                    sys_query=query,
-                    sys_files=files,
-                    context=context,
-                    memory=memory,
-                    model_config=model_config,
-                    prompt_template=cast(
-                        Sequence[LLMNodeChatModelMessage] | LLMNodeCompletionModelPromptTemplate,
-                        self.node_data.prompt_template,
-                    ),
-                    memory_config=self.node_data.memory,
-                    vision_enabled=self.node_data.vision.enabled,
-                    vision_detail=self.node_data.vision.configs.detail,
-                    variable_pool=variable_pool,
-                    jinja2_variables=self.node_data.prompt_config.jinja2_variables,
-                    tenant_id=self.tenant_id,
-                    context_files=context_files,
-                )
+            prompt_messages, stop = LLMNode.fetch_prompt_messages(
+                sys_query=query,
+                sys_files=files,
+                context=context,
+                memory=memory,
+                model_config=model_config,
+                prompt_template=self.node_data.prompt_template,
+                memory_config=self.node_data.memory,
+                vision_enabled=self.node_data.vision.enabled,
+                vision_detail=self.node_data.vision.configs.detail,
+                variable_pool=variable_pool,
+                jinja2_variables=self.node_data.prompt_config.jinja2_variables,
+                tenant_id=self.tenant_id,
+                context_files=context_files,
+            )
 
             # handle invoke result
             generator = LLMNode.invoke_llm(
@@ -274,7 +250,6 @@ class LLMNode(Node[LLMNodeData]):
                 node_id=self._node_id,
                 node_type=self.node_type,
                 reasoning_format=self.node_data.reasoning_format,
-                tenant_id=self.tenant_id,
             )
 
             structured_output: LLMStructuredOutput | None = None
@@ -326,7 +301,6 @@ class LLMNode(Node[LLMNodeData]):
                 "reasoning_content": reasoning_content,
                 "usage": jsonable_encoder(usage),
                 "finish_reason": finish_reason,
-                "context": llm_utils.build_context(prompt_messages, clean_text),
             }
             if structured_output:
                 outputs["structured_output"] = structured_output.structured_output
@@ -393,7 +367,6 @@ class LLMNode(Node[LLMNodeData]):
         node_id: str,
         node_type: NodeType,
         reasoning_format: Literal["separated", "tagged"] = "tagged",
-        tenant_id: str | None = None,
     ) -> Generator[NodeEventBase | LLMStructuredOutput, None, None]:
         model_schema = model_instance.model_type_instance.get_model_schema(
             node_data_model.name, model_instance.credentials
@@ -417,7 +390,6 @@ class LLMNode(Node[LLMNodeData]):
                 stop=list(stop or []),
                 stream=True,
                 user=user_id,
-                tenant_id=tenant_id,
             )
         else:
             request_start_time = time.perf_counter()
@@ -609,212 +581,6 @@ class LLMNode(Node[LLMNodeData]):
 
         return messages
 
-    def _parse_prompt_template(
-        self,
-    ) -> tuple[list[LLMNodeChatModelMessage], list[PromptMessageContext], list[tuple[int, str]]]:
-        """
-        Parse prompt_template to separate static messages and context references.
-
-        Returns:
-            Tuple of (static_messages, context_refs, template_order)
-            - static_messages: list of LLMNodeChatModelMessage
-            - context_refs: list of PromptMessageContext
-            - template_order: list of (index, type) tuples preserving original order
-        """
-        prompt_template = self.node_data.prompt_template
-        static_messages: list[LLMNodeChatModelMessage] = []
-        context_refs: list[PromptMessageContext] = []
-        template_order: list[tuple[int, str]] = []
-
-        if isinstance(prompt_template, list):
-            for idx, item in enumerate(prompt_template):
-                if isinstance(item, PromptMessageContext):
-                    context_refs.append(item)
-                    template_order.append((idx, "context"))
-                else:
-                    static_messages.append(item)
-                    template_order.append((idx, "static"))
-            # Transform static messages for jinja2
-            if static_messages:
-                self.node_data.prompt_template = self._transform_chat_messages(static_messages)
-
-        return static_messages, context_refs, template_order
-
-    def _build_prompt_messages_with_context(
-        self,
-        *,
-        context_refs: list[PromptMessageContext],
-        template_order: list[tuple[int, str]],
-        static_messages: list[LLMNodeChatModelMessage],
-        query: str | None,
-        files: Sequence[File],
-        context: str | None,
-        memory: BaseMemory | None,
-        model_config: ModelConfigWithCredentialsEntity,
-        context_files: list[File],
-    ) -> tuple[list[PromptMessage], Sequence[str] | None]:
-        """
-        Build prompt messages by combining static messages and context references in DSL order.
-
-        Returns:
-            Tuple of (prompt_messages, stop_sequences)
-        """
-        variable_pool = self.graph_runtime_state.variable_pool
-
-        # Process messages in DSL order: iterate once and handle each type directly
-        combined_messages: list[PromptMessage] = []
-        context_idx = 0
-        static_idx = 0
-
-        for _, type_ in template_order:
-            if type_ == "context":
-                # Handle context reference
-                ctx_ref = context_refs[context_idx]
-                ctx_var = variable_pool.get(ctx_ref.value_selector)
-                if ctx_var is None:
-                    raise VariableNotFoundError(f"Variable {'.'.join(ctx_ref.value_selector)} not found")
-                if not isinstance(ctx_var, ArrayPromptMessageSegment):
-                    raise InvalidVariableTypeError(f"Variable {'.'.join(ctx_ref.value_selector)} is not array[message]")
-                # Restore multimodal content (base64/url) that was truncated when saving context
-                restored_messages = llm_utils.restore_multimodal_content_in_messages(ctx_var.value)
-                combined_messages.extend(restored_messages)
-                context_idx += 1
-            else:
-                # Handle static message
-                static_msg = static_messages[static_idx]
-                processed_msgs = LLMNode.handle_list_messages(
-                    messages=[static_msg],
-                    context=context,
-                    jinja2_variables=self.node_data.prompt_config.jinja2_variables or [],
-                    variable_pool=variable_pool,
-                    vision_detail_config=self.node_data.vision.configs.detail,
-                )
-                combined_messages.extend(processed_msgs)
-                static_idx += 1
-
-        # Append memory messages
-        memory_messages = _handle_memory_chat_mode(
-            memory=memory,
-            memory_config=self.node_data.memory,
-            model_config=model_config,
-        )
-        combined_messages.extend(memory_messages)
-
-        # Append current query if provided
-        if query:
-            query_message = LLMNodeChatModelMessage(
-                text=query,
-                role=PromptMessageRole.USER,
-                edition_type="basic",
-            )
-            query_msgs = LLMNode.handle_list_messages(
-                messages=[query_message],
-                context="",
-                jinja2_variables=[],
-                variable_pool=variable_pool,
-                vision_detail_config=self.node_data.vision.configs.detail,
-            )
-            combined_messages.extend(query_msgs)
-
-        # Handle files (sys_files and context_files)
-        combined_messages = self._append_files_to_messages(
-            messages=combined_messages,
-            sys_files=files,
-            context_files=context_files,
-            model_config=model_config,
-        )
-
-        # Filter empty messages and get stop sequences
-        combined_messages = self._filter_messages(combined_messages, model_config)
-        stop = self._get_stop_sequences(model_config)
-
-        return combined_messages, stop
-
-    def _append_files_to_messages(
-        self,
-        *,
-        messages: list[PromptMessage],
-        sys_files: Sequence[File],
-        context_files: list[File],
-        model_config: ModelConfigWithCredentialsEntity,
-    ) -> list[PromptMessage]:
-        """Append sys_files and context_files to messages."""
-        vision_enabled = self.node_data.vision.enabled
-        vision_detail = self.node_data.vision.configs.detail
-
-        # Handle sys_files (will be deprecated later)
-        if vision_enabled and sys_files:
-            file_prompts = [
-                file_manager.to_prompt_message_content(file, image_detail_config=vision_detail) for file in sys_files
-            ]
-            if messages and isinstance(messages[-1], UserPromptMessage) and isinstance(messages[-1].content, list):
-                messages[-1] = UserPromptMessage(content=file_prompts + messages[-1].content)
-            else:
-                messages.append(UserPromptMessage(content=file_prompts))
-
-        # Handle context_files
-        if vision_enabled and context_files:
-            file_prompts = [
-                file_manager.to_prompt_message_content(file, image_detail_config=vision_detail)
-                for file in context_files
-            ]
-            if messages and isinstance(messages[-1], UserPromptMessage) and isinstance(messages[-1].content, list):
-                messages[-1] = UserPromptMessage(content=file_prompts + messages[-1].content)
-            else:
-                messages.append(UserPromptMessage(content=file_prompts))
-
-        return messages
-
-    def _filter_messages(
-        self, messages: list[PromptMessage], model_config: ModelConfigWithCredentialsEntity
-    ) -> list[PromptMessage]:
-        """Filter empty messages and unsupported content types."""
-        filtered_messages: list[PromptMessage] = []
-
-        for message in messages:
-            if isinstance(message.content, list):
-                filtered_content: list[PromptMessageContentUnionTypes] = []
-                for content_item in message.content:
-                    # Skip non-text content if features are not defined
-                    if not model_config.model_schema.features:
-                        if content_item.type != PromptMessageContentType.TEXT:
-                            continue
-                        filtered_content.append(content_item)
-                        continue
-
-                    # Skip content if corresponding feature is not supported
-                    feature_map = {
-                        PromptMessageContentType.IMAGE: ModelFeature.VISION,
-                        PromptMessageContentType.DOCUMENT: ModelFeature.DOCUMENT,
-                        PromptMessageContentType.VIDEO: ModelFeature.VIDEO,
-                        PromptMessageContentType.AUDIO: ModelFeature.AUDIO,
-                    }
-                    required_feature = feature_map.get(content_item.type)
-                    if required_feature and required_feature not in model_config.model_schema.features:
-                        continue
-                    filtered_content.append(content_item)
-
-                # Simplify single text content
-                if len(filtered_content) == 1 and filtered_content[0].type == PromptMessageContentType.TEXT:
-                    message.content = filtered_content[0].data
-                else:
-                    message.content = filtered_content
-
-            if not message.is_empty():
-                filtered_messages.append(message)
-
-        if not filtered_messages:
-            raise NoPromptFoundError(
-                "No prompt found in the LLM configuration. "
-                "Please ensure a prompt is properly configured before proceeding."
-            )
-
-        return filtered_messages
-
-    def _get_stop_sequences(self, model_config: ModelConfigWithCredentialsEntity) -> Sequence[str] | None:
-        """Get stop sequences from model config."""
-        return model_config.stop
-
     def _fetch_jinja_inputs(self, node_data: LLMNodeData) -> dict[str, str]:
         variables: dict[str, Any] = {}
 
@@ -1012,7 +778,7 @@ class LLMNode(Node[LLMNodeData]):
         sys_query: str | None = None,
         sys_files: Sequence[File],
         context: str | None = None,
-        memory: BaseMemory | None = None,
+        memory: TokenBufferMemory | None = None,
         model_config: ModelConfigWithCredentialsEntity,
         prompt_template: Sequence[LLMNodeChatModelMessage] | LLMNodeCompletionModelPromptTemplate,
         memory_config: MemoryConfig | None = None,
@@ -1571,7 +1337,7 @@ def _calculate_rest_token(
 
 def _handle_memory_chat_mode(
     *,
-    memory: BaseMemory | None,
+    memory: TokenBufferMemory | None,
     memory_config: MemoryConfig | None,
     model_config: ModelConfigWithCredentialsEntity,
 ) -> Sequence[PromptMessage]:
@@ -1588,7 +1354,7 @@ def _handle_memory_chat_mode(
 
 def _handle_memory_completion_mode(
     *,
-    memory: BaseMemory | None,
+    memory: TokenBufferMemory | None,
     memory_config: MemoryConfig | None,
     model_config: ModelConfigWithCredentialsEntity,
 ) -> str:

api/core/workflow/nodes/parameter_extractor/parameter_extractor_node.py

@@ -7,7 +7,7 @@ from typing import Any, cast
 
 from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
 from core.file import File
-from core.memory.base import BaseMemory
+from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance
 from core.model_runtime.entities import ImagePromptMessageContent
 from core.model_runtime.entities.llm_entities import LLMUsage
@@ -145,10 +145,8 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         memory = llm_utils.fetch_memory(
             variable_pool=variable_pool,
             app_id=self.app_id,
-            tenant_id=self.tenant_id,
             node_data_memory=node_data.memory,
             model_instance=model_instance,
-            node_id=self._node_id,
         )
 
         if (
@@ -246,10 +244,6 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         # transform result into standard format
         result = self._transform_result(data=node_data, result=result or {})
 
-        # Build context from prompt messages and response
-        assistant_response = json.dumps(result, ensure_ascii=False)
-        context = llm_utils.build_context(prompt_messages, assistant_response)
-
         return NodeRunResult(
             status=WorkflowNodeExecutionStatus.SUCCEEDED,
             inputs=inputs,
@@ -258,7 +252,6 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
                 "__is_success": 1 if not error else 0,
                 "__reason": error,
                 "__usage": jsonable_encoder(usage),
-                "context": context,
                 **result,
             },
             metadata={
@@ -306,7 +299,7 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         query: str,
         variable_pool: VariablePool,
         model_config: ModelConfigWithCredentialsEntity,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         files: Sequence[File],
         vision_detail: ImagePromptMessageContent.DETAIL | None = None,
     ) -> tuple[list[PromptMessage], list[PromptMessageTool]]:
@@ -388,7 +381,7 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         query: str,
         variable_pool: VariablePool,
         model_config: ModelConfigWithCredentialsEntity,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         files: Sequence[File],
         vision_detail: ImagePromptMessageContent.DETAIL | None = None,
     ) -> list[PromptMessage]:
@@ -426,7 +419,7 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         query: str,
         variable_pool: VariablePool,
         model_config: ModelConfigWithCredentialsEntity,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         files: Sequence[File],
         vision_detail: ImagePromptMessageContent.DETAIL | None = None,
     ) -> list[PromptMessage]:
@@ -460,7 +453,7 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         query: str,
         variable_pool: VariablePool,
         model_config: ModelConfigWithCredentialsEntity,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         files: Sequence[File],
         vision_detail: ImagePromptMessageContent.DETAIL | None = None,
     ) -> list[PromptMessage]:
@@ -688,7 +681,7 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         node_data: ParameterExtractorNodeData,
         query: str,
         variable_pool: VariablePool,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         max_token_limit: int = 2000,
     ) -> list[ChatModelMessage]:
         model_mode = ModelMode(node_data.model.mode)
@@ -715,7 +708,7 @@ class ParameterExtractorNode(Node[ParameterExtractorNodeData]):
         node_data: ParameterExtractorNodeData,
         query: str,
         variable_pool: VariablePool,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         max_token_limit: int = 2000,
     ):
         model_mode = ModelMode(node_data.model.mode)

api/core/workflow/nodes/question_classifier/question_classifier_node.py

@@ -4,7 +4,7 @@ from collections.abc import Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 
 from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
-from core.memory.base import BaseMemory
+from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance
 from core.model_runtime.entities import LLMUsage, ModelPropertyKey, PromptMessageRole
 from core.model_runtime.utils.encoders import jsonable_encoder
@@ -96,10 +96,8 @@ class QuestionClassifierNode(Node[QuestionClassifierNodeData]):
         memory = llm_utils.fetch_memory(
             variable_pool=variable_pool,
             app_id=self.app_id,
-            tenant_id=self.tenant_id,
             node_data_memory=node_data.memory,
             model_instance=model_instance,
-            node_id=self._node_id,
         )
         # fetch instruction
         node_data.instruction = node_data.instruction or ""
@@ -199,15 +197,10 @@ class QuestionClassifierNode(Node[QuestionClassifierNodeData]):
                 "model_provider": model_config.provider,
                 "model_name": model_config.model,
             }
-            # Build context from prompt messages and response
-            assistant_response = f"class_name: {category_name}, class_id: {category_id}"
-            context = llm_utils.build_context(prompt_messages, assistant_response)
-
             outputs = {
                 "class_name": category_name,
                 "class_id": category_id,
                 "usage": jsonable_encoder(usage),
-                "context": context,
             }
 
             return NodeRunResult(
@@ -319,7 +312,7 @@ class QuestionClassifierNode(Node[QuestionClassifierNodeData]):
         self,
         node_data: QuestionClassifierNodeData,
         query: str,
-        memory: BaseMemory | None,
+        memory: TokenBufferMemory | None,
         max_token_limit: int = 2000,
     ):
         model_mode = ModelMode(node_data.model.mode)

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

@@ -1,63 +1,11 @@
-import re
-from collections.abc import Sequence
-from typing import Any, Literal, Self, Union
+from typing import Any, Literal, Union
 
-from pydantic import BaseModel, field_validator, model_validator
+from pydantic import BaseModel, field_validator
 from pydantic_core.core_schema import ValidationInfo
 
 from core.tools.entities.tool_entities import ToolProviderType
 from core.workflow.nodes.base.entities import BaseNodeData
 
-# Pattern to match mention value format: {{@node.context@}}instruction
-# The placeholder {{@node.context@}} must appear at the beginning
-# Format: {{@agent_node_id.context@}} where agent_node_id is dynamic, context is fixed
-MENTION_VALUE_PATTERN = re.compile(r"^\{\{@([a-zA-Z0-9_]+)\.context@\}\}(.*)$", re.DOTALL)
-
-
-def parse_mention_value(value: str) -> tuple[str, str]:
-    """Parse mention value into (node_id, instruction).
-
-    Args:
-        value: The mention value string like "{{@llm.context@}}extract keywords"
-
-    Returns:
-        Tuple of (node_id, instruction)
-
-    Raises:
-        ValueError: If value format is invalid
-    """
-    match = MENTION_VALUE_PATTERN.match(value)
-    if not match:
-        raise ValueError(
-            "For mention type, value must start with {{@node.context@}} placeholder, "
-            "e.g., '{{@llm.context@}}extract keywords'"
-        )
-    return match.group(1), match.group(2)
-
-
-class MentionConfig(BaseModel):
-    """Configuration for extracting value from context variable.
-
-    Used when a tool parameter needs to be extracted from list[PromptMessage]
-    context using an extractor LLM node.
-
-    Note: instruction is embedded in the value field as "{{@node.context@}}instruction"
-    """
-
-    # ID of the extractor LLM node
-    extractor_node_id: str
-
-    # Output variable selector from extractor node
-    # e.g., ["text"], ["structured_output", "query"]
-    output_selector: Sequence[str]
-
-    # Strategy when output is None
-    null_strategy: Literal["raise_error", "use_default"] = "raise_error"
-
-    # Default value when null_strategy is "use_default"
-    # Type should match the parameter's expected type
-    default_value: Any = None
-
 
 class ToolEntity(BaseModel):
     provider_id: str
@@ -87,9 +35,7 @@ class ToolNodeData(BaseNodeData, ToolEntity):
     class ToolInput(BaseModel):
         # TODO: check this type
         value: Union[Any, list[str]]
-        type: Literal["mixed", "variable", "constant", "mention"]
-        # Required config for mention type, extracting value from context variable
-        mention_config: MentionConfig | None = None
+        type: Literal["mixed", "variable", "constant"]
 
         @field_validator("type", mode="before")
         @classmethod
@@ -102,9 +48,6 @@ class ToolNodeData(BaseNodeData, ToolEntity):
 
             if typ == "mixed" and not isinstance(value, str):
                 raise ValueError("value must be a string")
-            elif typ == "mention":
-                # Skip here, will be validated in model_validator
-                pass
             elif typ == "variable":
                 if not isinstance(value, list):
                     raise ValueError("value must be a list")
@@ -115,26 +58,6 @@ class ToolNodeData(BaseNodeData, ToolEntity):
                 raise ValueError("value must be a string, int, float, bool or dict")
             return typ
 
-        @model_validator(mode="after")
-        def check_mention_type(self) -> Self:
-            """Validate mention type with mention_config."""
-            if self.type != "mention":
-                return self
-
-            value = self.value
-            if value is None:
-                return self
-
-            if not isinstance(value, str):
-                raise ValueError("value must be a string for mention type")
-            # For mention type, value must match format: {{@node.context@}}instruction
-            # This will raise ValueError if format is invalid
-            parse_mention_value(value)
-            # mention_config is required for mention type
-            if self.mention_config is None:
-                raise ValueError("mention_config is required for mention type")
-            return self
-
     tool_parameters: dict[str, ToolInput]
     # The version of the tool parameter.
     # If this value is None, it indicates this is a previous version

api/core/workflow/nodes/tool/tool_node.py

@@ -1,10 +1,7 @@
-import logging
 from collections.abc import Generator, Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 
 from sqlalchemy import select
-
-logger = logging.getLogger(__name__)
 from sqlalchemy.orm import Session
 
 from core.callback_handler.workflow_tool_callback_handler import DifyWorkflowCallbackHandler
@@ -187,7 +184,6 @@ class ToolNode(Node[ToolNodeData]):
             tool_parameters (Sequence[ToolParameter]): The list of tool parameters.
             variable_pool (VariablePool): The variable pool containing the variables.
             node_data (ToolNodeData): The data associated with the tool node.
-            for_log (bool): Whether to generate parameters for logging.
 
         Returns:
             Mapping[str, Any]: A dictionary containing the generated parameters.
@@ -203,37 +199,14 @@ class ToolNode(Node[ToolNodeData]):
                 continue
             tool_input = node_data.tool_parameters[parameter_name]
             if tool_input.type == "variable":
-                if not isinstance(tool_input.value, list):
-                    raise ToolParameterError(f"Invalid variable selector for parameter '{parameter_name}'")
-                selector = tool_input.value
-                variable = variable_pool.get(selector)
+                variable = variable_pool.get(tool_input.value)
                 if variable is None:
                     if parameter.required:
-                        raise ToolParameterError(f"Variable {selector} does not exist")
+                        raise ToolParameterError(f"Variable {tool_input.value} does not exist")
                     continue
                 parameter_value = variable.value
-            elif tool_input.type == "mention":
-                # Mention type: get value from extractor node's output
-                if tool_input.mention_config is None:
-                    raise ToolParameterError(
-                        f"mention_config is required for mention type parameter '{parameter_name}'"
-                    )
-                mention_config = tool_input.mention_config.model_dump()
-                try:
-                    parameter_value, found = variable_pool.resolve_mention(
-                        mention_config, parameter_name=parameter_name
-                    )
-                    if not found and parameter.required:
-                        raise ToolParameterError(
-                            f"Extractor output not found for required parameter '{parameter_name}'"
-                        )
-                    if not found:
-                        continue
-                except ValueError as e:
-                    raise ToolParameterError(str(e)) from e
             elif tool_input.type in {"mixed", "constant"}:
-                template = str(tool_input.value)
-                segment_group = variable_pool.convert_template(template)
+                segment_group = variable_pool.convert_template(str(tool_input.value))
                 parameter_value = segment_group.log if for_log else segment_group.text
             else:
                 raise ToolParameterError(f"Unknown tool input type '{tool_input.type}'")
@@ -515,12 +488,8 @@ class ToolNode(Node[ToolNodeData]):
                 for selector in selectors:
                     result[selector.variable] = selector.value_selector
             elif input.type == "variable":
-                if isinstance(input.value, list):
-                    selector_key = ".".join(input.value)
-                    result[f"#{selector_key}#"] = input.value
-            elif input.type == "mention":
-                # Mention type: value is handled by extractor node, no direct variable reference
-                pass
+                selector_key = ".".join(input.value)
+                result[f"#{selector_key}#"] = input.value
             elif input.type == "constant":
                 pass
 

api/core/workflow/runtime/variable_pool.py

@@ -268,58 +268,6 @@ class VariablePool(BaseModel):
                 continue
             self.add(selector, value)
 
-    def resolve_mention(
-        self,
-        mention_config: Mapping[str, Any],
-        /,
-        *,
-        parameter_name: str = "",
-    ) -> tuple[Any, bool]:
-        """
-        Resolve a mention parameter value from an extractor node's output.
-
-        Mention parameters reference values extracted by an extractor LLM node
-        from list[PromptMessage] context.
-
-        Args:
-            mention_config: A dict containing:
-                - extractor_node_id: ID of the extractor LLM node
-                - output_selector: Selector path for the output variable (e.g., ["text"])
-                - null_strategy: "raise_error" or "use_default"
-                - default_value: Value to use when null_strategy is "use_default"
-            parameter_name: Name of the parameter being resolved (for error messages)
-
-        Returns:
-            Tuple of (resolved_value, found):
-                - resolved_value: The extracted value, or default_value if not found
-                - found: True if value was found, False if using default
-
-        Raises:
-            ValueError: If extractor_node_id is missing, or if null_strategy is
-                       "raise_error" and the value is not found
-        """
-        extractor_node_id = mention_config.get("extractor_node_id")
-        if not extractor_node_id:
-            raise ValueError(f"Missing extractor_node_id for mention parameter '{parameter_name}'")
-
-        output_selector = list(mention_config.get("output_selector", []))
-        null_strategy = mention_config.get("null_strategy", "raise_error")
-        default_value = mention_config.get("default_value")
-
-        # Build full selector: [extractor_node_id, ...output_selector]
-        full_selector = [extractor_node_id] + output_selector
-        variable = self.get(full_selector)
-
-        if variable is None:
-            if null_strategy == "use_default":
-                return default_value, False
-            raise ValueError(
-                f"Extractor node '{extractor_node_id}' output '{'.'.join(output_selector)}' "
-                f"not found for parameter '{parameter_name}'"
-            )
-
-        return variable.value, True
-
     @classmethod
     def empty(cls) -> VariablePool:
         """Create an empty variable pool."""

api/extensions/ext_commands.py

@@ -4,6 +4,7 @@ from dify_app import DifyApp
 def init_app(app: DifyApp):
     from commands import (
         add_qdrant_index,
+        archive_workflow_runs,
         clean_expired_messages,
         clean_workflow_runs,
         cleanup_orphaned_draft_variables,
@@ -11,6 +12,7 @@ def init_app(app: DifyApp):
         clear_orphaned_file_records,
         convert_to_agent_apps,
         create_tenant,
+        delete_archived_workflow_runs,
         extract_plugins,
         extract_unique_plugins,
         file_usage,
@@ -24,6 +26,7 @@ def init_app(app: DifyApp):
         reset_email,
         reset_encrypt_key_pair,
         reset_password,
+        restore_workflow_runs,
         setup_datasource_oauth_client,
         setup_system_tool_oauth_client,
         setup_system_trigger_oauth_client,
@@ -58,6 +61,9 @@ def init_app(app: DifyApp):
         setup_datasource_oauth_client,
         transform_datasource_credentials,
         install_rag_pipeline_plugins,
+        archive_workflow_runs,
+        delete_archived_workflow_runs,
+        restore_workflow_runs,
         clean_workflow_runs,
         clean_expired_messages,
     ]

api/factories/variable_factory.py

@@ -4,7 +4,6 @@ from uuid import uuid4
 
 from configs import dify_config
 from core.file import File
-from core.model_runtime.entities import PromptMessage
 from core.variables.exc import VariableError
 from core.variables.segments import (
     ArrayAnySegment,
@@ -12,7 +11,6 @@ from core.variables.segments import (
     ArrayFileSegment,
     ArrayNumberSegment,
     ArrayObjectSegment,
-    ArrayPromptMessageSegment,
     ArraySegment,
     ArrayStringSegment,
     BooleanSegment,
@@ -31,7 +29,6 @@ from core.variables.variables import (
     ArrayFileVariable,
     ArrayNumberVariable,
     ArrayObjectVariable,
-    ArrayPromptMessageVariable,
     ArrayStringVariable,
     BooleanVariable,
     FileVariable,
@@ -64,7 +61,6 @@ SEGMENT_TO_VARIABLE_MAP = {
     ArrayFileSegment: ArrayFileVariable,
     ArrayNumberSegment: ArrayNumberVariable,
     ArrayObjectSegment: ArrayObjectVariable,
-    ArrayPromptMessageSegment: ArrayPromptMessageVariable,
     ArrayStringSegment: ArrayStringVariable,
     BooleanSegment: BooleanVariable,
     FileSegment: FileVariable,
@@ -160,13 +156,7 @@ def build_segment(value: Any, /) -> Segment:
         return ObjectSegment(value=value)
     if isinstance(value, File):
         return FileSegment(value=value)
-    if isinstance(value, PromptMessage):
-        # Single PromptMessage should be wrapped in a list
-        return ArrayPromptMessageSegment(value=[value])
     if isinstance(value, list):
-        # Check if all items are PromptMessage
-        if value and all(isinstance(item, PromptMessage) for item in value):
-            return ArrayPromptMessageSegment(value=value)
         items = [build_segment(item) for item in value]
         types = {item.value_type for item in items}
         if all(isinstance(item, ArraySegment) for item in items):
@@ -210,7 +200,6 @@ _segment_factory: Mapping[SegmentType, type[Segment]] = {
     SegmentType.ARRAY_OBJECT: ArrayObjectSegment,
     SegmentType.ARRAY_FILE: ArrayFileSegment,
     SegmentType.ARRAY_BOOLEAN: ArrayBooleanSegment,
-    SegmentType.ARRAY_PROMPT_MESSAGE: ArrayPromptMessageSegment,
 }
 
 
@@ -285,10 +274,6 @@ def build_segment_with_type(segment_type: SegmentType, value: Any) -> Segment:
     ):
         segment_class = _segment_factory[inferred_type]
         return segment_class(value_type=inferred_type, value=value)
-    elif segment_type == SegmentType.ARRAY_PROMPT_MESSAGE and inferred_type == SegmentType.ARRAY_OBJECT:
-        # PromptMessage serializes to dict, so ARRAY_OBJECT is compatible with ARRAY_PROMPT_MESSAGE
-        segment_class = _segment_factory[segment_type]
-        return segment_class(value_type=segment_type, value=value)
     else:
         raise TypeMismatchError(f"Type mismatch: expected {segment_type}, but got {inferred_type}, value={value}")
 

api/fields/workflow_app_log_fields.py

@@ -2,7 +2,12 @@ from flask_restx import Namespace, fields
 
 from fields.end_user_fields import build_simple_end_user_model, simple_end_user_fields
 from fields.member_fields import build_simple_account_model, simple_account_fields
-from fields.workflow_run_fields import build_workflow_run_for_log_model, workflow_run_for_log_fields
+from fields.workflow_run_fields import (
+    build_workflow_run_for_archived_log_model,
+    build_workflow_run_for_log_model,
+    workflow_run_for_archived_log_fields,
+    workflow_run_for_log_fields,
+)
 from libs.helper import TimestampField
 
 workflow_app_log_partial_fields = {
@@ -34,6 +39,33 @@ def build_workflow_app_log_partial_model(api_or_ns: Namespace):
     return api_or_ns.model("WorkflowAppLogPartial", copied_fields)
 
 
+workflow_archived_log_partial_fields = {
+    "id": fields.String,
+    "workflow_run": fields.Nested(workflow_run_for_archived_log_fields, allow_null=True),
+    "trigger_metadata": fields.Raw,
+    "created_by_account": fields.Nested(simple_account_fields, attribute="created_by_account", allow_null=True),
+    "created_by_end_user": fields.Nested(simple_end_user_fields, attribute="created_by_end_user", allow_null=True),
+    "created_at": TimestampField,
+}
+
+
+def build_workflow_archived_log_partial_model(api_or_ns: Namespace):
+    """Build the workflow archived log partial model for the API or Namespace."""
+    workflow_run_model = build_workflow_run_for_archived_log_model(api_or_ns)
+    simple_account_model = build_simple_account_model(api_or_ns)
+    simple_end_user_model = build_simple_end_user_model(api_or_ns)
+
+    copied_fields = workflow_archived_log_partial_fields.copy()
+    copied_fields["workflow_run"] = fields.Nested(workflow_run_model, allow_null=True)
+    copied_fields["created_by_account"] = fields.Nested(
+        simple_account_model, attribute="created_by_account", allow_null=True
+    )
+    copied_fields["created_by_end_user"] = fields.Nested(
+        simple_end_user_model, attribute="created_by_end_user", allow_null=True
+    )
+    return api_or_ns.model("WorkflowArchivedLogPartial", copied_fields)
+
+
 workflow_app_log_pagination_fields = {
     "page": fields.Integer,
     "limit": fields.Integer,
@@ -51,3 +83,21 @@ def build_workflow_app_log_pagination_model(api_or_ns: Namespace):
     copied_fields = workflow_app_log_pagination_fields.copy()
     copied_fields["data"] = fields.List(fields.Nested(workflow_app_log_partial_model))
     return api_or_ns.model("WorkflowAppLogPagination", copied_fields)
+
+
+workflow_archived_log_pagination_fields = {
+    "page": fields.Integer,
+    "limit": fields.Integer,
+    "total": fields.Integer,
+    "has_more": fields.Boolean,
+    "data": fields.List(fields.Nested(workflow_archived_log_partial_fields)),
+}
+
+
+def build_workflow_archived_log_pagination_model(api_or_ns: Namespace):
+    """Build the workflow archived log pagination model for the API or Namespace."""
+    workflow_archived_log_partial_model = build_workflow_archived_log_partial_model(api_or_ns)
+
+    copied_fields = workflow_archived_log_pagination_fields.copy()
+    copied_fields["data"] = fields.List(fields.Nested(workflow_archived_log_partial_model))
+    return api_or_ns.model("WorkflowArchivedLogPagination", copied_fields)

api/fields/workflow_run_fields.py

@@ -23,6 +23,19 @@ def build_workflow_run_for_log_model(api_or_ns: Namespace):
     return api_or_ns.model("WorkflowRunForLog", workflow_run_for_log_fields)
 
 
+workflow_run_for_archived_log_fields = {
+    "id": fields.String,
+    "status": fields.String,
+    "triggered_from": fields.String,
+    "elapsed_time": fields.Float,
+    "total_tokens": fields.Integer,
+}
+
+
+def build_workflow_run_for_archived_log_model(api_or_ns: Namespace):
+    return api_or_ns.model("WorkflowRunForArchivedLog", workflow_run_for_archived_log_fields)
+
+
 workflow_run_for_list_fields = {
     "id": fields.String,
     "version": fields.String,

api/libs/archive_storage.py

@@ -7,7 +7,6 @@ to S3-compatible object storage.
 
 import base64
 import datetime
-import gzip
 import hashlib
 import logging
 from collections.abc import Generator
@@ -39,7 +38,7 @@ class ArchiveStorage:
     """
     S3-compatible storage client for archiving or exporting.
 
-    This client provides methods for storing and retrieving archived data in JSONL+gzip format.
+    This client provides methods for storing and retrieving archived data in JSONL format.
     """
 
     def __init__(self, bucket: str):
@@ -69,7 +68,10 @@ class ArchiveStorage:
             aws_access_key_id=dify_config.ARCHIVE_STORAGE_ACCESS_KEY,
             aws_secret_access_key=dify_config.ARCHIVE_STORAGE_SECRET_KEY,
             region_name=dify_config.ARCHIVE_STORAGE_REGION,
-            config=Config(s3={"addressing_style": "path"}),
+            config=Config(
+                s3={"addressing_style": "path"},
+                max_pool_connections=64,
+            ),
         )
 
         # Verify bucket accessibility
@@ -100,12 +102,18 @@ class ArchiveStorage:
         """
         checksum = hashlib.md5(data).hexdigest()
         try:
-            self.client.put_object(
+            response = self.client.put_object(
                 Bucket=self.bucket,
                 Key=key,
                 Body=data,
                 ContentMD5=self._content_md5(data),
             )
+            etag = response.get("ETag")
+            if not etag:
+                raise ArchiveStorageError(f"Missing ETag for '{key}'")
+            normalized_etag = etag.strip('"')
+            if normalized_etag != checksum:
+                raise ArchiveStorageError(f"ETag mismatch for '{key}': expected={checksum}, actual={normalized_etag}")
             logger.debug("Uploaded object: %s (size=%d, checksum=%s)", key, len(data), checksum)
             return checksum
         except ClientError as e:
@@ -240,19 +248,18 @@ class ArchiveStorage:
         return base64.b64encode(hashlib.md5(data).digest()).decode()
 
     @staticmethod
-    def serialize_to_jsonl_gz(records: list[dict[str, Any]]) -> bytes:
+    def serialize_to_jsonl(records: list[dict[str, Any]]) -> bytes:
         """
-        Serialize records to gzipped JSONL format.
+        Serialize records to JSONL format.
 
         Args:
             records: List of dictionaries to serialize
 
         Returns:
-            Gzipped JSONL bytes
+            JSONL bytes
         """
         lines = []
         for record in records:
-            # Convert datetime objects to ISO format strings
             serialized = ArchiveStorage._serialize_record(record)
             lines.append(orjson.dumps(serialized))
 
@@ -260,23 +267,22 @@ class ArchiveStorage:
         if jsonl_content:
             jsonl_content += b"\n"
 
-        return gzip.compress(jsonl_content)
+        return jsonl_content
 
     @staticmethod
-    def deserialize_from_jsonl_gz(data: bytes) -> list[dict[str, Any]]:
+    def deserialize_from_jsonl(data: bytes) -> list[dict[str, Any]]:
         """
-        Deserialize gzipped JSONL data to records.
+        Deserialize JSONL data to records.
 
         Args:
-            data: Gzipped JSONL bytes
+            data: JSONL bytes
 
         Returns:
             List of dictionaries
         """
-        jsonl_content = gzip.decompress(data)
         records = []
 
-        for line in jsonl_content.splitlines():
+        for line in data.splitlines():
             if line:
                 records.append(orjson.loads(line))
 

api/migrations/versions/2026_01_21_1718-9d77545f524e_add_workflow_archive_logs.py

@@ -0,0 +1,95 @@
+"""create workflow_archive_logs
+
+Revision ID: 9d77545f524e
+Revises: 7df29de0f6be
+Create Date: 2026-01-06 17:18:56.292479
+
+"""
+from alembic import op
+import models as models
+import sqlalchemy as sa
+
+
+def _is_pg(conn):
+    return conn.dialect.name == "postgresql"
+
+# revision identifiers, used by Alembic.
+revision = '9d77545f524e'
+down_revision = '7df29de0f6be'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    if _is_pg(conn):
+        op.create_table('workflow_archive_logs',
+        sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuidv7()'), nullable=False),
+        sa.Column('log_id', models.types.StringUUID(), nullable=True),
+        sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
+        sa.Column('app_id', models.types.StringUUID(), nullable=False),
+        sa.Column('workflow_id', models.types.StringUUID(), nullable=False),
+        sa.Column('workflow_run_id', models.types.StringUUID(), nullable=False),
+        sa.Column('created_by_role', sa.String(length=255), nullable=False),
+        sa.Column('created_by', models.types.StringUUID(), nullable=False),
+        sa.Column('log_created_at', sa.DateTime(), nullable=True),
+        sa.Column('log_created_from', sa.String(length=255), nullable=True),
+        sa.Column('run_version', sa.String(length=255), nullable=False),
+        sa.Column('run_status', sa.String(length=255), nullable=False),
+        sa.Column('run_triggered_from', sa.String(length=255), nullable=False),
+        sa.Column('run_error', models.types.LongText(), nullable=True),
+        sa.Column('run_elapsed_time', sa.Float(), server_default=sa.text('0'), nullable=False),
+        sa.Column('run_total_tokens', sa.BigInteger(), server_default=sa.text('0'), nullable=False),
+        sa.Column('run_total_steps', sa.Integer(), server_default=sa.text('0'), nullable=True),
+        sa.Column('run_created_at', sa.DateTime(), nullable=False),
+        sa.Column('run_finished_at', sa.DateTime(), nullable=True),
+        sa.Column('run_exceptions_count', sa.Integer(), server_default=sa.text('0'), nullable=True),
+        sa.Column('trigger_metadata', models.types.LongText(), nullable=True),
+        sa.Column('archived_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
+        sa.PrimaryKeyConstraint('id', name='workflow_archive_log_pkey')
+        )
+    else:
+        op.create_table('workflow_archive_logs',
+        sa.Column('id', models.types.StringUUID(), nullable=False),
+        sa.Column('log_id', models.types.StringUUID(), nullable=True),
+        sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
+        sa.Column('app_id', models.types.StringUUID(), nullable=False),
+        sa.Column('workflow_id', models.types.StringUUID(), nullable=False),
+        sa.Column('workflow_run_id', models.types.StringUUID(), nullable=False),
+        sa.Column('created_by_role', sa.String(length=255), nullable=False),
+        sa.Column('created_by', models.types.StringUUID(), nullable=False),
+        sa.Column('log_created_at', sa.DateTime(), nullable=True),
+        sa.Column('log_created_from', sa.String(length=255), nullable=True),
+        sa.Column('run_version', sa.String(length=255), nullable=False),
+        sa.Column('run_status', sa.String(length=255), nullable=False),
+        sa.Column('run_triggered_from', sa.String(length=255), nullable=False),
+        sa.Column('run_error', models.types.LongText(), nullable=True),
+        sa.Column('run_elapsed_time', sa.Float(), server_default=sa.text('0'), nullable=False),
+        sa.Column('run_total_tokens', sa.BigInteger(), server_default=sa.text('0'), nullable=False),
+        sa.Column('run_total_steps', sa.Integer(), server_default=sa.text('0'), nullable=True),
+        sa.Column('run_created_at', sa.DateTime(), nullable=False),
+        sa.Column('run_finished_at', sa.DateTime(), nullable=True),
+        sa.Column('run_exceptions_count', sa.Integer(), server_default=sa.text('0'), nullable=True),
+        sa.Column('trigger_metadata', models.types.LongText(), nullable=True),
+        sa.Column('archived_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
+        sa.PrimaryKeyConstraint('id', name='workflow_archive_log_pkey')
+        )
+    with op.batch_alter_table('workflow_archive_logs', schema=None) as batch_op:
+        batch_op.create_index('workflow_archive_log_app_idx', ['tenant_id', 'app_id'], unique=False)
+        batch_op.create_index('workflow_archive_log_run_created_at_idx', ['run_created_at'], unique=False)
+        batch_op.create_index('workflow_archive_log_workflow_run_id_idx', ['workflow_run_id'], unique=False)
+
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('workflow_archive_logs', schema=None) as batch_op:
+        batch_op.drop_index('workflow_archive_log_workflow_run_id_idx')
+        batch_op.drop_index('workflow_archive_log_run_created_at_idx')
+        batch_op.drop_index('workflow_archive_log_app_idx')
+
+    op.drop_table('workflow_archive_logs')
+    # ### end Alembic commands ###

api/models/__init__.py

@@ -100,6 +100,7 @@ from .workflow import (
     Workflow,
     WorkflowAppLog,
     WorkflowAppLogCreatedFrom,
+    WorkflowArchiveLog,
     WorkflowNodeExecutionModel,
     WorkflowNodeExecutionOffload,
     WorkflowNodeExecutionTriggeredFrom,
@@ -197,6 +198,7 @@ __all__ = [
     "Workflow",
     "WorkflowAppLog",
     "WorkflowAppLogCreatedFrom",
+    "WorkflowArchiveLog",
     "WorkflowNodeExecutionModel",
     "WorkflowNodeExecutionOffload",
     "WorkflowNodeExecutionTriggeredFrom",

api/models/workflow.py

@@ -1163,6 +1163,69 @@ class WorkflowAppLog(TypeBase):
         }
 
 
+class WorkflowArchiveLog(TypeBase):
+    """
+    Workflow archive log.
+
+    Stores essential workflow run snapshot data for archived app logs.
+
+    Field sources:
+    - Shared fields (tenant/app/workflow/run ids, created_by*): from WorkflowRun for consistency.
+    - log_* fields: from WorkflowAppLog when present; null if the run has no app log.
+    - run_* fields: workflow run snapshot fields from WorkflowRun.
+    - trigger_metadata: snapshot from WorkflowTriggerLog when present.
+    """
+
+    __tablename__ = "workflow_archive_logs"
+    __table_args__ = (
+        sa.PrimaryKeyConstraint("id", name="workflow_archive_log_pkey"),
+        sa.Index("workflow_archive_log_app_idx", "tenant_id", "app_id"),
+        sa.Index("workflow_archive_log_workflow_run_id_idx", "workflow_run_id"),
+        sa.Index("workflow_archive_log_run_created_at_idx", "run_created_at"),
+    )
+
+    id: Mapped[str] = mapped_column(
+        StringUUID, insert_default=lambda: str(uuidv7()), default_factory=lambda: str(uuidv7()), init=False
+    )
+
+    tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    workflow_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    workflow_run_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+    created_by_role: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
+
+    log_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+    log_created_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    log_created_from: Mapped[str | None] = mapped_column(String(255), nullable=True)
+
+    run_version: Mapped[str] = mapped_column(String(255), nullable=False)
+    run_status: Mapped[str] = mapped_column(String(255), nullable=False)
+    run_triggered_from: Mapped[str] = mapped_column(String(255), nullable=False)
+    run_error: Mapped[str | None] = mapped_column(LongText, nullable=True)
+    run_elapsed_time: Mapped[float] = mapped_column(sa.Float, nullable=False, server_default=sa.text("0"))
+    run_total_tokens: Mapped[int] = mapped_column(sa.BigInteger, server_default=sa.text("0"))
+    run_total_steps: Mapped[int] = mapped_column(sa.Integer, server_default=sa.text("0"), nullable=True)
+    run_created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    run_finished_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    run_exceptions_count: Mapped[int] = mapped_column(sa.Integer, server_default=sa.text("0"), nullable=True)
+
+    trigger_metadata: Mapped[str | None] = mapped_column(LongText, nullable=True)
+    archived_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+    )
+
+    @property
+    def workflow_run_summary(self) -> dict[str, Any]:
+        return {
+            "id": self.workflow_run_id,
+            "status": self.run_status,
+            "triggered_from": self.run_triggered_from,
+            "elapsed_time": self.run_elapsed_time,
+            "total_tokens": self.run_total_tokens,
+        }
+
+
 class ConversationVariable(TypeBase):
     __tablename__ = "workflow_conversation_variables"
 
@@ -1285,7 +1348,7 @@ class WorkflowDraftVariable(Base):
     # which may differ from the original value's type. Typically, they are the same,
     # but in cases where the structurally truncated  value still exceeds the size limit,
     # text slicing is applied, and the `value_type` is converted to `STRING`.
-    value_type: Mapped[SegmentType] = mapped_column(EnumText(SegmentType, length=21))
+    value_type: Mapped[SegmentType] = mapped_column(EnumText(SegmentType, length=20))
 
     # The variable's value serialized as a JSON string
     #
@@ -1659,7 +1722,7 @@ class WorkflowDraftVariableFile(Base):
 
     # The `value_type` field records the type of the original value.
     value_type: Mapped[SegmentType] = mapped_column(
-        EnumText(SegmentType, length=21),
+        EnumText(SegmentType, length=20),
         nullable=False,
     )
 

api/repositories/api_workflow_run_repository.py

@@ -45,7 +45,7 @@ from core.workflow.enums import WorkflowType
 from core.workflow.repositories.workflow_execution_repository import WorkflowExecutionRepository
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from models.enums import WorkflowRunTriggeredFrom
-from models.workflow import WorkflowRun
+from models.workflow import WorkflowAppLog, WorkflowArchiveLog, WorkflowPause, WorkflowPauseReason, WorkflowRun
 from repositories.entities.workflow_pause import WorkflowPauseEntity
 from repositories.types import (
     AverageInteractionStats,
@@ -270,6 +270,38 @@ class APIWorkflowRunRepository(WorkflowExecutionRepository, Protocol):
         """
         ...
 
+    def get_archived_run_ids(
+        self,
+        session: Session,
+        run_ids: Sequence[str],
+    ) -> set[str]:
+        """
+        Fetch workflow run IDs that already have archive log records.
+        """
+        ...
+
+    def get_archived_logs_by_time_range(
+        self,
+        session: Session,
+        tenant_ids: Sequence[str] | None,
+        start_date: datetime,
+        end_date: datetime,
+        limit: int,
+    ) -> Sequence[WorkflowArchiveLog]:
+        """
+        Fetch archived workflow logs by time range for restore.
+        """
+        ...
+
+    def get_archived_log_by_run_id(
+        self,
+        run_id: str,
+    ) -> WorkflowArchiveLog | None:
+        """
+        Fetch a workflow archive log by workflow run ID.
+        """
+        ...
+
     def delete_runs_with_related(
         self,
         runs: Sequence[WorkflowRun],
@@ -282,6 +314,61 @@ class APIWorkflowRunRepository(WorkflowExecutionRepository, Protocol):
         """
         ...
 
+    def get_pause_records_by_run_id(
+        self,
+        session: Session,
+        run_id: str,
+    ) -> Sequence[WorkflowPause]:
+        """
+        Fetch workflow pause records by workflow run ID.
+        """
+        ...
+
+    def get_pause_reason_records_by_run_id(
+        self,
+        session: Session,
+        pause_ids: Sequence[str],
+    ) -> Sequence[WorkflowPauseReason]:
+        """
+        Fetch workflow pause reason records by pause IDs.
+        """
+        ...
+
+    def get_app_logs_by_run_id(
+        self,
+        session: Session,
+        run_id: str,
+    ) -> Sequence[WorkflowAppLog]:
+        """
+        Fetch workflow app logs by workflow run ID.
+        """
+        ...
+
+    def create_archive_logs(
+        self,
+        session: Session,
+        run: WorkflowRun,
+        app_logs: Sequence[WorkflowAppLog],
+        trigger_metadata: str | None,
+    ) -> int:
+        """
+        Create archive log records for a workflow run.
+        """
+        ...
+
+    def get_archived_runs_by_time_range(
+        self,
+        session: Session,
+        tenant_ids: Sequence[str] | None,
+        start_date: datetime,
+        end_date: datetime,
+        limit: int,
+    ) -> Sequence[WorkflowRun]:
+        """
+        Return workflow runs that already have archive logs, for cleanup of `workflow_runs`.
+        """
+        ...
+
     def count_runs_with_related(
         self,
         runs: Sequence[WorkflowRun],

api/repositories/sqlalchemy_api_workflow_node_execution_repository.py

@@ -351,3 +351,27 @@ class DifyAPISQLAlchemyWorkflowNodeExecutionRepository(DifyAPIWorkflowNodeExecut
         )
 
         return int(node_executions_count), int(offloads_count)
+
+    @staticmethod
+    def get_by_run(
+        session: Session,
+        run_id: str,
+    ) -> Sequence[WorkflowNodeExecutionModel]:
+        """
+        Fetch node executions for a run using workflow_run_id.
+        """
+        stmt = select(WorkflowNodeExecutionModel).where(WorkflowNodeExecutionModel.workflow_run_id == run_id)
+        return list(session.scalars(stmt))
+
+    @staticmethod
+    def get_offloads_by_execution_ids(
+        session: Session,
+        node_execution_ids: Sequence[str],
+    ) -> Sequence[WorkflowNodeExecutionOffload]:
+        if not node_execution_ids:
+            return []
+
+        stmt = select(WorkflowNodeExecutionOffload).where(
+            WorkflowNodeExecutionOffload.node_execution_id.in_(node_execution_ids)
+        )
+        return list(session.scalars(stmt))

api/repositories/sqlalchemy_api_workflow_run_repository.py

@@ -40,14 +40,7 @@ from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from libs.time_parser import get_time_threshold
 from libs.uuid_utils import uuidv7
 from models.enums import WorkflowRunTriggeredFrom
-from models.workflow import (
-    WorkflowAppLog,
-    WorkflowPauseReason,
-    WorkflowRun,
-)
-from models.workflow import (
-    WorkflowPause as WorkflowPauseModel,
-)
+from models.workflow import WorkflowAppLog, WorkflowArchiveLog, WorkflowPause, WorkflowPauseReason, WorkflowRun
 from repositories.api_workflow_run_repository import APIWorkflowRunRepository
 from repositories.entities.workflow_pause import WorkflowPauseEntity
 from repositories.types import (
@@ -369,6 +362,44 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
 
             return session.scalars(stmt).all()
 
+    def get_archived_run_ids(
+        self,
+        session: Session,
+        run_ids: Sequence[str],
+    ) -> set[str]:
+        if not run_ids:
+            return set()
+
+        stmt = select(WorkflowArchiveLog.workflow_run_id).where(WorkflowArchiveLog.workflow_run_id.in_(run_ids))
+        return set(session.scalars(stmt).all())
+
+    def get_archived_log_by_run_id(
+        self,
+        run_id: str,
+    ) -> WorkflowArchiveLog | None:
+        with self._session_maker() as session:
+            stmt = select(WorkflowArchiveLog).where(WorkflowArchiveLog.workflow_run_id == run_id).limit(1)
+            return session.scalar(stmt)
+
+    def get_pause_records_by_run_id(
+        self,
+        session: Session,
+        run_id: str,
+    ) -> Sequence[WorkflowPause]:
+        stmt = select(WorkflowPause).where(WorkflowPause.workflow_run_id == run_id)
+        return list(session.scalars(stmt))
+
+    def get_pause_reason_records_by_run_id(
+        self,
+        session: Session,
+        pause_ids: Sequence[str],
+    ) -> Sequence[WorkflowPauseReason]:
+        if not pause_ids:
+            return []
+
+        stmt = select(WorkflowPauseReason).where(WorkflowPauseReason.pause_id.in_(pause_ids))
+        return list(session.scalars(stmt))
+
     def delete_runs_with_related(
         self,
         runs: Sequence[WorkflowRun],
@@ -396,9 +427,8 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
             app_logs_result = session.execute(delete(WorkflowAppLog).where(WorkflowAppLog.workflow_run_id.in_(run_ids)))
             app_logs_deleted = cast(CursorResult, app_logs_result).rowcount or 0
 
-            pause_ids = session.scalars(
-                select(WorkflowPauseModel.id).where(WorkflowPauseModel.workflow_run_id.in_(run_ids))
-            ).all()
+            pause_stmt = select(WorkflowPause.id).where(WorkflowPause.workflow_run_id.in_(run_ids))
+            pause_ids = session.scalars(pause_stmt).all()
             pause_reasons_deleted = 0
             pauses_deleted = 0
 
@@ -407,7 +437,7 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
                     delete(WorkflowPauseReason).where(WorkflowPauseReason.pause_id.in_(pause_ids))
                 )
                 pause_reasons_deleted = cast(CursorResult, pause_reasons_result).rowcount or 0
-                pauses_result = session.execute(delete(WorkflowPauseModel).where(WorkflowPauseModel.id.in_(pause_ids)))
+                pauses_result = session.execute(delete(WorkflowPause).where(WorkflowPause.id.in_(pause_ids)))
                 pauses_deleted = cast(CursorResult, pauses_result).rowcount or 0
 
             trigger_logs_deleted = delete_trigger_logs(session, run_ids) if delete_trigger_logs else 0
@@ -427,6 +457,124 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
                 "pause_reasons": pause_reasons_deleted,
             }
 
+    def get_app_logs_by_run_id(
+        self,
+        session: Session,
+        run_id: str,
+    ) -> Sequence[WorkflowAppLog]:
+        stmt = select(WorkflowAppLog).where(WorkflowAppLog.workflow_run_id == run_id)
+        return list(session.scalars(stmt))
+
+    def create_archive_logs(
+        self,
+        session: Session,
+        run: WorkflowRun,
+        app_logs: Sequence[WorkflowAppLog],
+        trigger_metadata: str | None,
+    ) -> int:
+        if not app_logs:
+            archive_log = WorkflowArchiveLog(
+                log_id=None,
+                log_created_at=None,
+                log_created_from=None,
+                tenant_id=run.tenant_id,
+                app_id=run.app_id,
+                workflow_id=run.workflow_id,
+                workflow_run_id=run.id,
+                created_by_role=run.created_by_role,
+                created_by=run.created_by,
+                run_version=run.version,
+                run_status=run.status,
+                run_triggered_from=run.triggered_from,
+                run_error=run.error,
+                run_elapsed_time=run.elapsed_time,
+                run_total_tokens=run.total_tokens,
+                run_total_steps=run.total_steps,
+                run_created_at=run.created_at,
+                run_finished_at=run.finished_at,
+                run_exceptions_count=run.exceptions_count,
+                trigger_metadata=trigger_metadata,
+            )
+            session.add(archive_log)
+            return 1
+
+        archive_logs = [
+            WorkflowArchiveLog(
+                log_id=app_log.id,
+                log_created_at=app_log.created_at,
+                log_created_from=app_log.created_from,
+                tenant_id=run.tenant_id,
+                app_id=run.app_id,
+                workflow_id=run.workflow_id,
+                workflow_run_id=run.id,
+                created_by_role=run.created_by_role,
+                created_by=run.created_by,
+                run_version=run.version,
+                run_status=run.status,
+                run_triggered_from=run.triggered_from,
+                run_error=run.error,
+                run_elapsed_time=run.elapsed_time,
+                run_total_tokens=run.total_tokens,
+                run_total_steps=run.total_steps,
+                run_created_at=run.created_at,
+                run_finished_at=run.finished_at,
+                run_exceptions_count=run.exceptions_count,
+                trigger_metadata=trigger_metadata,
+            )
+            for app_log in app_logs
+        ]
+        session.add_all(archive_logs)
+        return len(archive_logs)
+
+    def get_archived_runs_by_time_range(
+        self,
+        session: Session,
+        tenant_ids: Sequence[str] | None,
+        start_date: datetime,
+        end_date: datetime,
+        limit: int,
+    ) -> Sequence[WorkflowRun]:
+        """
+        Retrieves WorkflowRun records by joining workflow_archive_logs.
+
+        Used to identify runs that are already archived and ready for deletion.
+        """
+        stmt = (
+            select(WorkflowRun)
+            .join(WorkflowArchiveLog, WorkflowArchiveLog.workflow_run_id == WorkflowRun.id)
+            .where(
+                WorkflowArchiveLog.run_created_at >= start_date,
+                WorkflowArchiveLog.run_created_at < end_date,
+            )
+            .order_by(WorkflowArchiveLog.run_created_at.asc(), WorkflowArchiveLog.workflow_run_id.asc())
+            .limit(limit)
+        )
+        if tenant_ids:
+            stmt = stmt.where(WorkflowArchiveLog.tenant_id.in_(tenant_ids))
+        return list(session.scalars(stmt))
+
+    def get_archived_logs_by_time_range(
+        self,
+        session: Session,
+        tenant_ids: Sequence[str] | None,
+        start_date: datetime,
+        end_date: datetime,
+        limit: int,
+    ) -> Sequence[WorkflowArchiveLog]:
+        # Returns WorkflowArchiveLog rows directly; use this when workflow_runs may be deleted.
+        stmt = (
+            select(WorkflowArchiveLog)
+            .where(
+                WorkflowArchiveLog.run_created_at >= start_date,
+                WorkflowArchiveLog.run_created_at < end_date,
+            )
+            .order_by(WorkflowArchiveLog.run_created_at.asc(), WorkflowArchiveLog.workflow_run_id.asc())
+            .limit(limit)
+        )
+        if tenant_ids:
+            stmt = stmt.where(WorkflowArchiveLog.tenant_id.in_(tenant_ids))
+        return list(session.scalars(stmt))
+
     def count_runs_with_related(
         self,
         runs: Sequence[WorkflowRun],
@@ -459,7 +607,7 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
             )
 
             pause_ids = session.scalars(
-                select(WorkflowPauseModel.id).where(WorkflowPauseModel.workflow_run_id.in_(run_ids))
+                select(WorkflowPause.id).where(WorkflowPause.workflow_run_id.in_(run_ids))
             ).all()
             pauses_count = len(pause_ids)
             pause_reasons_count = 0
@@ -511,9 +659,7 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
             ValueError: If workflow_run_id is invalid or workflow run doesn't exist
             RuntimeError: If workflow is already paused or in invalid state
         """
-        previous_pause_model_query = select(WorkflowPauseModel).where(
-            WorkflowPauseModel.workflow_run_id == workflow_run_id
-        )
+        previous_pause_model_query = select(WorkflowPause).where(WorkflowPause.workflow_run_id == workflow_run_id)
         with self._session_maker() as session, session.begin():
             # Get the workflow run
             workflow_run = session.get(WorkflowRun, workflow_run_id)
@@ -538,7 +684,7 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
             # Upload the state file
 
             # Create the pause record
-            pause_model = WorkflowPauseModel()
+            pause_model = WorkflowPause()
             pause_model.id = str(uuidv7())
             pause_model.workflow_id = workflow_run.workflow_id
             pause_model.workflow_run_id = workflow_run.id
@@ -710,13 +856,13 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
         """
         with self._session_maker() as session, session.begin():
             # Get the pause model by ID
-            pause_model = session.get(WorkflowPauseModel, pause_entity.id)
+            pause_model = session.get(WorkflowPause, pause_entity.id)
             if pause_model is None:
                 raise _WorkflowRunError(f"WorkflowPause not found: {pause_entity.id}")
             self._delete_pause_model(session, pause_model)
 
     @staticmethod
-    def _delete_pause_model(session: Session, pause_model: WorkflowPauseModel):
+    def _delete_pause_model(session: Session, pause_model: WorkflowPause):
         storage.delete(pause_model.state_object_key)
 
         # Delete the pause record
@@ -751,15 +897,15 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
         _limit: int = limit or 1000
         pruned_record_ids: list[str] = []
         cond = or_(
-            WorkflowPauseModel.created_at < expiration,
+            WorkflowPause.created_at < expiration,
             and_(
-                WorkflowPauseModel.resumed_at.is_not(null()),
-                WorkflowPauseModel.resumed_at < resumption_expiration,
+                WorkflowPause.resumed_at.is_not(null()),
+                WorkflowPause.resumed_at < resumption_expiration,
             ),
         )
         # First, collect pause records to delete with their state files
         # Expired pauses (created before expiration time)
-        stmt = select(WorkflowPauseModel).where(cond).limit(_limit)
+        stmt = select(WorkflowPause).where(cond).limit(_limit)
 
         with self._session_maker(expire_on_commit=False) as session:
             # Old resumed pauses (resumed more than resumption_duration ago)
@@ -770,7 +916,7 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
         # Delete state files from storage
         for pause in pauses_to_delete:
             with self._session_maker(expire_on_commit=False) as session, session.begin():
-                # todo: this issues a separate query for each WorkflowPauseModel record.
+                # todo: this issues a separate query for each WorkflowPause record.
                 # consider batching this lookup.
                 try:
                     storage.delete(pause.state_object_key)
@@ -1022,7 +1168,7 @@ class _PrivateWorkflowPauseEntity(WorkflowPauseEntity):
     def __init__(
         self,
         *,
-        pause_model: WorkflowPauseModel,
+        pause_model: WorkflowPause,
         reason_models: Sequence[WorkflowPauseReason],
         human_input_form: Sequence = (),
     ) -> None:

api/repositories/sqlalchemy_workflow_trigger_log_repository.py

@@ -46,6 +46,11 @@ class SQLAlchemyWorkflowTriggerLogRepository(WorkflowTriggerLogRepository):
 
         return self.session.scalar(query)
 
+    def list_by_run_id(self, run_id: str) -> Sequence[WorkflowTriggerLog]:
+        """List trigger logs for a workflow run."""
+        query = select(WorkflowTriggerLog).where(WorkflowTriggerLog.workflow_run_id == run_id)
+        return list(self.session.scalars(query).all())
+
     def get_failed_for_retry(
         self, tenant_id: str, max_retry_count: int = 3, limit: int = 100
     ) -> Sequence[WorkflowTriggerLog]:

api/services/dataset_service.py

@@ -13,10 +13,11 @@ import sqlalchemy as sa
 from redis.exceptions import LockNotOwnedError
 from sqlalchemy import exists, func, select
 from sqlalchemy.orm import Session
-from werkzeug.exceptions import NotFound
+from werkzeug.exceptions import Forbidden, NotFound
 
 from configs import dify_config
 from core.errors.error import LLMBadRequestError, ProviderTokenNotInitError
+from core.file import helpers as file_helpers
 from core.helper.name_generator import generate_incremental_name
 from core.model_manager import ModelManager
 from core.model_runtime.entities.model_entities import ModelFeature, ModelType
@@ -73,6 +74,7 @@ from services.errors.document import DocumentIndexingError
 from services.errors.file import FileNotExistsError
 from services.external_knowledge_service import ExternalDatasetService
 from services.feature_service import FeatureModel, FeatureService
+from services.file_service import FileService
 from services.rag_pipeline.rag_pipeline import RagPipelineService
 from services.tag_service import TagService
 from services.vector_service import VectorService
@@ -1162,6 +1164,7 @@ class DocumentService:
             Document.archived.is_(True),
         ),
     }
+    DOCUMENT_BATCH_DOWNLOAD_ZIP_FILENAME_EXTENSION = ".zip"
 
     @classmethod
     def normalize_display_status(cls, status: str | None) -> str | None:
@@ -1288,6 +1291,143 @@ class DocumentService:
         else:
             return None
 
+    @staticmethod
+    def get_documents_by_ids(dataset_id: str, document_ids: Sequence[str]) -> Sequence[Document]:
+        """Fetch documents for a dataset in a single batch query."""
+        if not document_ids:
+            return []
+        document_id_list: list[str] = [str(document_id) for document_id in document_ids]
+        # Fetch all requested documents in one query to avoid N+1 lookups.
+        documents: Sequence[Document] = db.session.scalars(
+            select(Document).where(
+                Document.dataset_id == dataset_id,
+                Document.id.in_(document_id_list),
+            )
+        ).all()
+        return documents
+
+    @staticmethod
+    def get_document_download_url(document: Document) -> str:
+        """
+        Return a signed download URL for an upload-file document.
+        """
+        upload_file = DocumentService._get_upload_file_for_upload_file_document(document)
+        return file_helpers.get_signed_file_url(upload_file_id=upload_file.id, as_attachment=True)
+
+    @staticmethod
+    def prepare_document_batch_download_zip(
+        *,
+        dataset_id: str,
+        document_ids: Sequence[str],
+        tenant_id: str,
+        current_user: Account,
+    ) -> tuple[list[UploadFile], str]:
+        """
+        Resolve upload files for batch ZIP downloads and generate a client-visible filename.
+        """
+        dataset = DatasetService.get_dataset(dataset_id)
+        if not dataset:
+            raise NotFound("Dataset not found.")
+        try:
+            DatasetService.check_dataset_permission(dataset, current_user)
+        except NoPermissionError as e:
+            raise Forbidden(str(e))
+
+        upload_files_by_document_id = DocumentService._get_upload_files_by_document_id_for_zip_download(
+            dataset_id=dataset_id,
+            document_ids=document_ids,
+            tenant_id=tenant_id,
+        )
+        upload_files = [upload_files_by_document_id[document_id] for document_id in document_ids]
+        download_name = DocumentService._generate_document_batch_download_zip_filename()
+        return upload_files, download_name
+
+    @staticmethod
+    def _generate_document_batch_download_zip_filename() -> str:
+        """
+        Generate a random attachment filename for the batch download ZIP.
+        """
+        return f"{uuid.uuid4().hex}{DocumentService.DOCUMENT_BATCH_DOWNLOAD_ZIP_FILENAME_EXTENSION}"
+
+    @staticmethod
+    def _get_upload_file_id_for_upload_file_document(
+        document: Document,
+        *,
+        invalid_source_message: str,
+        missing_file_message: str,
+    ) -> str:
+        """
+        Normalize and validate `Document -> UploadFile` linkage for download flows.
+        """
+        if document.data_source_type != "upload_file":
+            raise NotFound(invalid_source_message)
+
+        data_source_info: dict[str, Any] = document.data_source_info_dict or {}
+        upload_file_id: str | None = data_source_info.get("upload_file_id")
+        if not upload_file_id:
+            raise NotFound(missing_file_message)
+
+        return str(upload_file_id)
+
+    @staticmethod
+    def _get_upload_file_for_upload_file_document(document: Document) -> UploadFile:
+        """
+        Load the `UploadFile` row for an upload-file document.
+        """
+        upload_file_id = DocumentService._get_upload_file_id_for_upload_file_document(
+            document,
+            invalid_source_message="Document does not have an uploaded file to download.",
+            missing_file_message="Uploaded file not found.",
+        )
+        upload_files_by_id = FileService.get_upload_files_by_ids(document.tenant_id, [upload_file_id])
+        upload_file = upload_files_by_id.get(upload_file_id)
+        if not upload_file:
+            raise NotFound("Uploaded file not found.")
+        return upload_file
+
+    @staticmethod
+    def _get_upload_files_by_document_id_for_zip_download(
+        *,
+        dataset_id: str,
+        document_ids: Sequence[str],
+        tenant_id: str,
+    ) -> dict[str, UploadFile]:
+        """
+        Batch load upload files keyed by document id for ZIP downloads.
+        """
+        document_id_list: list[str] = [str(document_id) for document_id in document_ids]
+
+        documents = DocumentService.get_documents_by_ids(dataset_id, document_id_list)
+        documents_by_id: dict[str, Document] = {str(document.id): document for document in documents}
+
+        missing_document_ids: set[str] = set(document_id_list) - set(documents_by_id.keys())
+        if missing_document_ids:
+            raise NotFound("Document not found.")
+
+        upload_file_ids: list[str] = []
+        upload_file_ids_by_document_id: dict[str, str] = {}
+        for document_id, document in documents_by_id.items():
+            if document.tenant_id != tenant_id:
+                raise Forbidden("No permission.")
+
+            upload_file_id = DocumentService._get_upload_file_id_for_upload_file_document(
+                document,
+                invalid_source_message="Only uploaded-file documents can be downloaded as ZIP.",
+                missing_file_message="Only uploaded-file documents can be downloaded as ZIP.",
+            )
+            upload_file_ids.append(upload_file_id)
+            upload_file_ids_by_document_id[document_id] = upload_file_id
+
+        upload_files_by_id = FileService.get_upload_files_by_ids(tenant_id, upload_file_ids)
+        missing_upload_file_ids: set[str] = set(upload_file_ids) - set(upload_files_by_id.keys())
+        if missing_upload_file_ids:
+            raise NotFound("Only uploaded-file documents can be downloaded as ZIP.")
+
+        return {
+            document_id: upload_files_by_id[upload_file_id]
+            for document_id, upload_file_id in upload_file_ids_by_document_id.items()
+        }
+
     @staticmethod
     def get_document_by_id(document_id: str) -> Document | None:
         document = db.session.query(Document).where(Document.id == document_id).first()

api/services/file_service.py

@@ -2,7 +2,11 @@ import base64
 import hashlib
 import os
 import uuid
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager, suppress
+from tempfile import NamedTemporaryFile
 from typing import Literal, Union
+from zipfile import ZIP_DEFLATED, ZipFile
 
 from sqlalchemy import Engine, select
 from sqlalchemy.orm import Session, sessionmaker
@@ -17,6 +21,7 @@ from constants import (
 )
 from core.file import helpers as file_helpers
 from core.rag.extractor.extract_processor import ExtractProcessor
+from extensions.ext_database import db
 from extensions.ext_storage import storage
 from libs.datetime_utils import naive_utc_now
 from libs.helper import extract_tenant_id
@@ -167,6 +172,9 @@ class FileService:
         return upload_file
 
     def get_file_preview(self, file_id: str):
+        """
+        Return a short text preview extracted from a document file.
+        """
         with self._session_maker(expire_on_commit=False) as session:
             upload_file = session.query(UploadFile).where(UploadFile.id == file_id).first()
 
@@ -253,3 +261,101 @@ class FileService:
                 return
             storage.delete(upload_file.key)
             session.delete(upload_file)
+
+    @staticmethod
+    def get_upload_files_by_ids(tenant_id: str, upload_file_ids: Sequence[str]) -> dict[str, UploadFile]:
+        """
+        Fetch `UploadFile` rows for a tenant in a single batch query.
+
+        This is a generic `UploadFile` lookup helper (not dataset/document specific), so it lives in `FileService`.
+        """
+        if not upload_file_ids:
+            return {}
+
+        # Normalize and deduplicate ids before using them in the IN clause.
+        upload_file_id_list: list[str] = [str(upload_file_id) for upload_file_id in upload_file_ids]
+        unique_upload_file_ids: list[str] = list(set(upload_file_id_list))
+
+        # Fetch upload files in one query for efficient batch access.
+        upload_files: Sequence[UploadFile] = db.session.scalars(
+            select(UploadFile).where(
+                UploadFile.tenant_id == tenant_id,
+                UploadFile.id.in_(unique_upload_file_ids),
+            )
+        ).all()
+        return {str(upload_file.id): upload_file for upload_file in upload_files}
+
+    @staticmethod
+    def _sanitize_zip_entry_name(name: str) -> str:
+        """
+        Sanitize a ZIP entry name to avoid path traversal and weird separators.
+
+        We keep this conservative: the upload flow already rejects `/` and `\\`, but older rows (or imported data)
+        could still contain unsafe names.
+        """
+        # Drop any directory components and prevent empty names.
+        base = os.path.basename(name).strip() or "file"
+
+        # ZIP uses forward slashes as separators; remove any residual separator characters.
+        return base.replace("/", "_").replace("\\", "_")
+
+    @staticmethod
+    def _dedupe_zip_entry_name(original_name: str, used_names: set[str]) -> str:
+        """
+        Return a unique ZIP entry name, inserting suffixes before the extension.
+        """
+        # Keep the original name when it's not already used.
+        if original_name not in used_names:
+            return original_name
+
+        # Insert suffixes before the extension (e.g., "doc.txt" -> "doc (1).txt").
+        stem, extension = os.path.splitext(original_name)
+        suffix = 1
+        while True:
+            candidate = f"{stem} ({suffix}){extension}"
+            if candidate not in used_names:
+                return candidate
+            suffix += 1
+
+    @staticmethod
+    @contextmanager
+    def build_upload_files_zip_tempfile(
+        *,
+        upload_files: Sequence[UploadFile],
+    ) -> Iterator[str]:
+        """
+        Build a ZIP from `UploadFile`s and yield a tempfile path.
+
+        We yield a path (rather than an open file handle) to avoid "read of closed file" issues when Flask/Werkzeug
+        streams responses. The caller is expected to keep this context open until the response is fully sent, then
+        close it (e.g., via `response.call_on_close(...)`) to delete the tempfile.
+        """
+        used_names: set[str] = set()
+
+        # Build a ZIP in a temp file and keep it on disk until the caller finishes streaming it.
+        tmp_path: str | None = None
+        try:
+            with NamedTemporaryFile(mode="w+b", suffix=".zip", delete=False) as tmp:
+                tmp_path = tmp.name
+                with ZipFile(tmp, mode="w", compression=ZIP_DEFLATED) as zf:
+                    for upload_file in upload_files:
+                        # Ensure the entry name is safe and unique.
+                        safe_name = FileService._sanitize_zip_entry_name(upload_file.name)
+                        arcname = FileService._dedupe_zip_entry_name(safe_name, used_names)
+                        used_names.add(arcname)
+
+                        # Stream file bytes from storage into the ZIP entry.
+                        with zf.open(arcname, "w") as entry:
+                            for chunk in storage.load(upload_file.key, stream=True):
+                                entry.write(chunk)
+
+                # Flush so `send_file(path, ...)` can re-open it safely on all platforms.
+                tmp.flush()
+
+            assert tmp_path is not None
+            yield tmp_path
+        finally:
+            # Remove the temp file when the context is closed (typically after the response finishes streaming).
+            if tmp_path is not None:
+                with suppress(FileNotFoundError):
+                    os.remove(tmp_path)

api/services/retention/workflow_run/__init__.py

@@ -0,0 +1 @@
+"""Workflow run retention services."""

api/services/retention/workflow_run/archive_paid_plan_workflow_run.py

@@ -0,0 +1,519 @@
+"""
+Archive Paid Plan Workflow Run Logs Service.
+
+This service archives workflow run logs for paid plan users older than the configured
+retention period (default: 90 days) to S3-compatible storage.
+
+Archived tables:
+- workflow_runs
+- workflow_app_logs
+- workflow_node_executions
+- workflow_node_execution_offload
+- workflow_pauses
+- workflow_pause_reasons
+- workflow_trigger_logs
+
+"""
+
+import datetime
+import io
+import json
+import logging
+import time
+import zipfile
+from collections.abc import Sequence
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from typing import Any
+
+import click
+from sqlalchemy import inspect
+from sqlalchemy.orm import Session, sessionmaker
+
+from configs import dify_config
+from core.workflow.enums import WorkflowType
+from enums.cloud_plan import CloudPlan
+from extensions.ext_database import db
+from libs.archive_storage import (
+    ArchiveStorage,
+    ArchiveStorageNotConfiguredError,
+    get_archive_storage,
+)
+from models.workflow import WorkflowAppLog, WorkflowRun
+from repositories.api_workflow_run_repository import APIWorkflowRunRepository
+from repositories.sqlalchemy_api_workflow_node_execution_repository import (
+    DifyAPISQLAlchemyWorkflowNodeExecutionRepository,
+)
+from repositories.sqlalchemy_workflow_trigger_log_repository import SQLAlchemyWorkflowTriggerLogRepository
+from services.billing_service import BillingService
+from services.retention.workflow_run.constants import ARCHIVE_BUNDLE_NAME, ARCHIVE_SCHEMA_VERSION
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TableStats:
+    """Statistics for a single archived table."""
+
+    table_name: str
+    row_count: int
+    checksum: str
+    size_bytes: int
+
+
+@dataclass
+class ArchiveResult:
+    """Result of archiving a single workflow run."""
+
+    run_id: str
+    tenant_id: str
+    success: bool
+    tables: list[TableStats] = field(default_factory=list)
+    error: str | None = None
+    elapsed_time: float = 0.0
+
+
+@dataclass
+class ArchiveSummary:
+    """Summary of the entire archive operation."""
+
+    total_runs_processed: int = 0
+    runs_archived: int = 0
+    runs_skipped: int = 0
+    runs_failed: int = 0
+    total_elapsed_time: float = 0.0
+
+
+class WorkflowRunArchiver:
+    """
+    Archive workflow run logs for paid plan users.
+
+    Storage Layout:
+    {tenant_id}/app_id={app_id}/year={YYYY}/month={MM}/workflow_run_id={run_id}/
+        └── archive.v1.0.zip
+            ├── manifest.json
+            ├── workflow_runs.jsonl
+            ├── workflow_app_logs.jsonl
+            ├── workflow_node_executions.jsonl
+            ├── workflow_node_execution_offload.jsonl
+            ├── workflow_pauses.jsonl
+            ├── workflow_pause_reasons.jsonl
+            └── workflow_trigger_logs.jsonl
+    """
+
+    ARCHIVED_TYPE = [
+        WorkflowType.WORKFLOW,
+        WorkflowType.RAG_PIPELINE,
+    ]
+    ARCHIVED_TABLES = [
+        "workflow_runs",
+        "workflow_app_logs",
+        "workflow_node_executions",
+        "workflow_node_execution_offload",
+        "workflow_pauses",
+        "workflow_pause_reasons",
+        "workflow_trigger_logs",
+    ]
+
+    def __init__(
+        self,
+        days: int = 90,
+        batch_size: int = 100,
+        start_from: datetime.datetime | None = None,
+        end_before: datetime.datetime | None = None,
+        workers: int = 1,
+        tenant_ids: Sequence[str] | None = None,
+        limit: int | None = None,
+        dry_run: bool = False,
+        delete_after_archive: bool = False,
+        workflow_run_repo: APIWorkflowRunRepository | None = None,
+    ):
+        """
+        Initialize the archiver.
+
+        Args:
+            days: Archive runs older than this many days
+            batch_size: Number of runs to process per batch
+            start_from: Optional start time (inclusive) for archiving
+            end_before: Optional end time (exclusive) for archiving
+            workers: Number of concurrent workflow runs to archive
+            tenant_ids: Optional tenant IDs for grayscale rollout
+            limit: Maximum number of runs to archive (None for unlimited)
+            dry_run: If True, only preview without making changes
+            delete_after_archive: If True, delete runs and related data after archiving
+        """
+        self.days = days
+        self.batch_size = batch_size
+        if start_from or end_before:
+            if start_from is None or end_before is None:
+                raise ValueError("start_from and end_before must be provided together")
+            if start_from >= end_before:
+                raise ValueError("start_from must be earlier than end_before")
+            self.start_from = start_from.replace(tzinfo=datetime.UTC)
+            self.end_before = end_before.replace(tzinfo=datetime.UTC)
+        else:
+            self.start_from = None
+            self.end_before = datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=days)
+        if workers < 1:
+            raise ValueError("workers must be at least 1")
+        self.workers = workers
+        self.tenant_ids = sorted(set(tenant_ids)) if tenant_ids else []
+        self.limit = limit
+        self.dry_run = dry_run
+        self.delete_after_archive = delete_after_archive
+        self.workflow_run_repo = workflow_run_repo
+
+    def run(self) -> ArchiveSummary:
+        """
+        Main archiving loop.
+
+        Returns:
+            ArchiveSummary with statistics about the operation
+        """
+        summary = ArchiveSummary()
+        start_time = time.time()
+
+        click.echo(
+            click.style(
+                self._build_start_message(),
+                fg="white",
+            )
+        )
+
+        # Initialize archive storage (will raise if not configured)
+        try:
+            if not self.dry_run:
+                storage = get_archive_storage()
+            else:
+                storage = None
+        except ArchiveStorageNotConfiguredError as e:
+            click.echo(click.style(f"Archive storage not configured: {e}", fg="red"))
+            return summary
+
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        repo = self._get_workflow_run_repo()
+
+        def _archive_with_session(run: WorkflowRun) -> ArchiveResult:
+            with session_maker() as session:
+                return self._archive_run(session, storage, run)
+
+        last_seen: tuple[datetime.datetime, str] | None = None
+        archived_count = 0
+
+        with ThreadPoolExecutor(max_workers=self.workers) as executor:
+            while True:
+                # Check limit
+                if self.limit and archived_count >= self.limit:
+                    click.echo(click.style(f"Reached limit of {self.limit} runs", fg="yellow"))
+                    break
+
+                # Fetch batch of runs
+                runs = self._get_runs_batch(last_seen)
+
+                if not runs:
+                    break
+
+                run_ids = [run.id for run in runs]
+                with session_maker() as session:
+                    archived_run_ids = repo.get_archived_run_ids(session, run_ids)
+
+                last_seen = (runs[-1].created_at, runs[-1].id)
+
+                # Filter to paid tenants only
+                tenant_ids = {run.tenant_id for run in runs}
+                paid_tenants = self._filter_paid_tenants(tenant_ids)
+
+                runs_to_process: list[WorkflowRun] = []
+                for run in runs:
+                    summary.total_runs_processed += 1
+
+                    # Skip non-paid tenants
+                    if run.tenant_id not in paid_tenants:
+                        summary.runs_skipped += 1
+                        continue
+
+                    # Skip already archived runs
+                    if run.id in archived_run_ids:
+                        summary.runs_skipped += 1
+                        continue
+
+                    # Check limit
+                    if self.limit and archived_count + len(runs_to_process) >= self.limit:
+                        break
+
+                    runs_to_process.append(run)
+
+                if not runs_to_process:
+                    continue
+
+                results = list(executor.map(_archive_with_session, runs_to_process))
+
+                for run, result in zip(runs_to_process, results):
+                    if result.success:
+                        summary.runs_archived += 1
+                        archived_count += 1
+                        click.echo(
+                            click.style(
+                                f"{'[DRY RUN] Would archive' if self.dry_run else 'Archived'} "
+                                f"run {run.id} (tenant={run.tenant_id}, "
+                                f"tables={len(result.tables)}, time={result.elapsed_time:.2f}s)",
+                                fg="green",
+                            )
+                        )
+                    else:
+                        summary.runs_failed += 1
+                        click.echo(
+                            click.style(
+                                f"Failed to archive run {run.id}: {result.error}",
+                                fg="red",
+                            )
+                        )
+
+        summary.total_elapsed_time = time.time() - start_time
+        click.echo(
+            click.style(
+                f"{'[DRY RUN] ' if self.dry_run else ''}Archive complete: "
+                f"processed={summary.total_runs_processed}, archived={summary.runs_archived}, "
+                f"skipped={summary.runs_skipped}, failed={summary.runs_failed}, "
+                f"time={summary.total_elapsed_time:.2f}s",
+                fg="white",
+            )
+        )
+
+        return summary
+
+    def _get_runs_batch(
+        self,
+        last_seen: tuple[datetime.datetime, str] | None,
+    ) -> Sequence[WorkflowRun]:
+        """Fetch a batch of workflow runs to archive."""
+        repo = self._get_workflow_run_repo()
+        return repo.get_runs_batch_by_time_range(
+            start_from=self.start_from,
+            end_before=self.end_before,
+            last_seen=last_seen,
+            batch_size=self.batch_size,
+            run_types=self.ARCHIVED_TYPE,
+            tenant_ids=self.tenant_ids or None,
+        )
+
+    def _build_start_message(self) -> str:
+        range_desc = f"before {self.end_before.isoformat()}"
+        if self.start_from:
+            range_desc = f"between {self.start_from.isoformat()} and {self.end_before.isoformat()}"
+        return (
+            f"{'[DRY RUN] ' if self.dry_run else ''}Starting workflow run archiving "
+            f"for runs {range_desc} "
+            f"(batch_size={self.batch_size}, tenant_ids={','.join(self.tenant_ids) or 'all'})"
+        )
+
+    def _filter_paid_tenants(self, tenant_ids: set[str]) -> set[str]:
+        """Filter tenant IDs to only include paid tenants."""
+        if not dify_config.BILLING_ENABLED:
+            # If billing is not enabled, treat all tenants as paid
+            return tenant_ids
+
+        if not tenant_ids:
+            return set()
+
+        try:
+            bulk_info = BillingService.get_plan_bulk_with_cache(list(tenant_ids))
+        except Exception:
+            logger.exception("Failed to fetch billing plans for tenants")
+            # On error, skip all tenants in this batch
+            return set()
+
+        # Filter to paid tenants (any plan except SANDBOX)
+        paid = set()
+        for tid, info in bulk_info.items():
+            if info and info.get("plan") in (CloudPlan.PROFESSIONAL, CloudPlan.TEAM):
+                paid.add(tid)
+
+        return paid
+
+    def _archive_run(
+        self,
+        session: Session,
+        storage: ArchiveStorage | None,
+        run: WorkflowRun,
+    ) -> ArchiveResult:
+        """Archive a single workflow run."""
+        start_time = time.time()
+        result = ArchiveResult(run_id=run.id, tenant_id=run.tenant_id, success=False)
+
+        try:
+            # Extract data from all tables
+            table_data, app_logs, trigger_metadata = self._extract_data(session, run)
+
+            if self.dry_run:
+                # In dry run, just report what would be archived
+                for table_name in self.ARCHIVED_TABLES:
+                    records = table_data.get(table_name, [])
+                    result.tables.append(
+                        TableStats(
+                            table_name=table_name,
+                            row_count=len(records),
+                            checksum="",
+                            size_bytes=0,
+                        )
+                    )
+                result.success = True
+            else:
+                if storage is None:
+                    raise ArchiveStorageNotConfiguredError("Archive storage not configured")
+                archive_key = self._get_archive_key(run)
+
+                # Serialize tables for the archive bundle
+                table_stats: list[TableStats] = []
+                table_payloads: dict[str, bytes] = {}
+                for table_name in self.ARCHIVED_TABLES:
+                    records = table_data.get(table_name, [])
+                    data = ArchiveStorage.serialize_to_jsonl(records)
+                    table_payloads[table_name] = data
+                    checksum = ArchiveStorage.compute_checksum(data)
+
+                    table_stats.append(
+                        TableStats(
+                            table_name=table_name,
+                            row_count=len(records),
+                            checksum=checksum,
+                            size_bytes=len(data),
+                        )
+                    )
+
+                # Generate and upload archive bundle
+                manifest = self._generate_manifest(run, table_stats)
+                manifest_data = json.dumps(manifest, indent=2, default=str).encode("utf-8")
+                archive_data = self._build_archive_bundle(manifest_data, table_payloads)
+                storage.put_object(archive_key, archive_data)
+
+                repo = self._get_workflow_run_repo()
+                archived_log_count = repo.create_archive_logs(session, run, app_logs, trigger_metadata)
+                session.commit()
+
+                deleted_counts = None
+                if self.delete_after_archive:
+                    deleted_counts = repo.delete_runs_with_related(
+                        [run],
+                        delete_node_executions=self._delete_node_executions,
+                        delete_trigger_logs=self._delete_trigger_logs,
+                    )
+
+                logger.info(
+                    "Archived workflow run %s: tables=%s, archived_logs=%s, deleted=%s",
+                    run.id,
+                    {s.table_name: s.row_count for s in table_stats},
+                    archived_log_count,
+                    deleted_counts,
+                )
+
+                result.tables = table_stats
+                result.success = True
+
+        except Exception as e:
+            logger.exception("Failed to archive workflow run %s", run.id)
+            result.error = str(e)
+            session.rollback()
+
+        result.elapsed_time = time.time() - start_time
+        return result
+
+    def _extract_data(
+        self,
+        session: Session,
+        run: WorkflowRun,
+    ) -> tuple[dict[str, list[dict[str, Any]]], Sequence[WorkflowAppLog], str | None]:
+        table_data: dict[str, list[dict[str, Any]]] = {}
+        table_data["workflow_runs"] = [self._row_to_dict(run)]
+        repo = self._get_workflow_run_repo()
+        app_logs = repo.get_app_logs_by_run_id(session, run.id)
+        table_data["workflow_app_logs"] = [self._row_to_dict(row) for row in app_logs]
+        node_exec_records = DifyAPISQLAlchemyWorkflowNodeExecutionRepository.get_by_run(session, run.id)
+        node_exec_ids = [record.id for record in node_exec_records]
+        offload_records = DifyAPISQLAlchemyWorkflowNodeExecutionRepository.get_offloads_by_execution_ids(
+            session,
+            node_exec_ids,
+        )
+        table_data["workflow_node_executions"] = [self._row_to_dict(row) for row in node_exec_records]
+        table_data["workflow_node_execution_offload"] = [self._row_to_dict(row) for row in offload_records]
+        repo = self._get_workflow_run_repo()
+        pause_records = repo.get_pause_records_by_run_id(session, run.id)
+        pause_ids = [pause.id for pause in pause_records]
+        pause_reason_records = repo.get_pause_reason_records_by_run_id(
+            session,
+            pause_ids,
+        )
+        table_data["workflow_pauses"] = [self._row_to_dict(row) for row in pause_records]
+        table_data["workflow_pause_reasons"] = [self._row_to_dict(row) for row in pause_reason_records]
+        trigger_repo = SQLAlchemyWorkflowTriggerLogRepository(session)
+        trigger_records = trigger_repo.list_by_run_id(run.id)
+        table_data["workflow_trigger_logs"] = [self._row_to_dict(row) for row in trigger_records]
+        trigger_metadata = trigger_records[0].trigger_metadata if trigger_records else None
+        return table_data, app_logs, trigger_metadata
+
+    @staticmethod
+    def _row_to_dict(row: Any) -> dict[str, Any]:
+        mapper = inspect(row).mapper
+        return {str(column.name): getattr(row, mapper.get_property_by_column(column).key) for column in mapper.columns}
+
+    def _get_archive_key(self, run: WorkflowRun) -> str:
+        """Get the storage key for the archive bundle."""
+        created_at = run.created_at
+        prefix = (
+            f"{run.tenant_id}/app_id={run.app_id}/year={created_at.strftime('%Y')}/"
+            f"month={created_at.strftime('%m')}/workflow_run_id={run.id}"
+        )
+        return f"{prefix}/{ARCHIVE_BUNDLE_NAME}"
+
+    def _generate_manifest(
+        self,
+        run: WorkflowRun,
+        table_stats: list[TableStats],
+    ) -> dict[str, Any]:
+        """Generate a manifest for the archived workflow run."""
+        return {
+            "schema_version": ARCHIVE_SCHEMA_VERSION,
+            "workflow_run_id": run.id,
+            "tenant_id": run.tenant_id,
+            "app_id": run.app_id,
+            "workflow_id": run.workflow_id,
+            "created_at": run.created_at.isoformat(),
+            "archived_at": datetime.datetime.now(datetime.UTC).isoformat(),
+            "tables": {
+                stat.table_name: {
+                    "row_count": stat.row_count,
+                    "checksum": stat.checksum,
+                    "size_bytes": stat.size_bytes,
+                }
+                for stat in table_stats
+            },
+        }
+
+    def _build_archive_bundle(self, manifest_data: bytes, table_payloads: dict[str, bytes]) -> bytes:
+        buffer = io.BytesIO()
+        with zipfile.ZipFile(buffer, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
+            archive.writestr("manifest.json", manifest_data)
+            for table_name in self.ARCHIVED_TABLES:
+                data = table_payloads.get(table_name)
+                if data is None:
+                    raise ValueError(f"Missing archive payload for {table_name}")
+                archive.writestr(f"{table_name}.jsonl", data)
+        return buffer.getvalue()
+
+    def _delete_trigger_logs(self, session: Session, run_ids: Sequence[str]) -> int:
+        trigger_repo = SQLAlchemyWorkflowTriggerLogRepository(session)
+        return trigger_repo.delete_by_run_ids(run_ids)
+
+    def _delete_node_executions(self, session: Session, runs: Sequence[WorkflowRun]) -> tuple[int, int]:
+        run_ids = [run.id for run in runs]
+        return DifyAPISQLAlchemyWorkflowNodeExecutionRepository.delete_by_runs(session, run_ids)
+
+    def _get_workflow_run_repo(self) -> APIWorkflowRunRepository:
+        if self.workflow_run_repo is not None:
+            return self.workflow_run_repo
+
+        from repositories.factory import DifyAPIRepositoryFactory
+
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        self.workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+        return self.workflow_run_repo

api/services/retention/workflow_run/constants.py

@@ -0,0 +1,2 @@
+ARCHIVE_SCHEMA_VERSION = "1.0"
+ARCHIVE_BUNDLE_NAME = f"archive.v{ARCHIVE_SCHEMA_VERSION}.zip"

api/services/retention/workflow_run/delete_archived_workflow_run.py

@@ -0,0 +1,132 @@
+"""
+Delete Archived Workflow Run Service.
+
+This service deletes archived workflow run data from the database while keeping
+archive logs intact.
+"""
+
+import time
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from sqlalchemy.orm import Session, sessionmaker
+
+from extensions.ext_database import db
+from models.workflow import WorkflowRun
+from repositories.api_workflow_run_repository import APIWorkflowRunRepository
+from repositories.sqlalchemy_api_workflow_node_execution_repository import (
+    DifyAPISQLAlchemyWorkflowNodeExecutionRepository,
+)
+from repositories.sqlalchemy_workflow_trigger_log_repository import SQLAlchemyWorkflowTriggerLogRepository
+
+
+@dataclass
+class DeleteResult:
+    run_id: str
+    tenant_id: str
+    success: bool
+    deleted_counts: dict[str, int] = field(default_factory=dict)
+    error: str | None = None
+    elapsed_time: float = 0.0
+
+
+class ArchivedWorkflowRunDeletion:
+    def __init__(self, dry_run: bool = False):
+        self.dry_run = dry_run
+        self.workflow_run_repo: APIWorkflowRunRepository | None = None
+
+    def delete_by_run_id(self, run_id: str) -> DeleteResult:
+        start_time = time.time()
+        result = DeleteResult(run_id=run_id, tenant_id="", success=False)
+
+        repo = self._get_workflow_run_repo()
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        with session_maker() as session:
+            run = session.get(WorkflowRun, run_id)
+            if not run:
+                result.error = f"Workflow run {run_id} not found"
+                result.elapsed_time = time.time() - start_time
+                return result
+
+            result.tenant_id = run.tenant_id
+            if not repo.get_archived_run_ids(session, [run.id]):
+                result.error = f"Workflow run {run_id} is not archived"
+                result.elapsed_time = time.time() - start_time
+                return result
+
+        result = self._delete_run(run)
+        result.elapsed_time = time.time() - start_time
+        return result
+
+    def delete_batch(
+        self,
+        tenant_ids: list[str] | None,
+        start_date: datetime,
+        end_date: datetime,
+        limit: int = 100,
+    ) -> list[DeleteResult]:
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        results: list[DeleteResult] = []
+
+        repo = self._get_workflow_run_repo()
+        with session_maker() as session:
+            runs = list(
+                repo.get_archived_runs_by_time_range(
+                    session=session,
+                    tenant_ids=tenant_ids,
+                    start_date=start_date,
+                    end_date=end_date,
+                    limit=limit,
+                )
+            )
+        for run in runs:
+            results.append(self._delete_run(run))
+
+        return results
+
+    def _delete_run(self, run: WorkflowRun) -> DeleteResult:
+        start_time = time.time()
+        result = DeleteResult(run_id=run.id, tenant_id=run.tenant_id, success=False)
+        if self.dry_run:
+            result.success = True
+            result.elapsed_time = time.time() - start_time
+            return result
+
+        repo = self._get_workflow_run_repo()
+        try:
+            deleted_counts = repo.delete_runs_with_related(
+                [run],
+                delete_node_executions=self._delete_node_executions,
+                delete_trigger_logs=self._delete_trigger_logs,
+            )
+            result.deleted_counts = deleted_counts
+            result.success = True
+        except Exception as e:
+            result.error = str(e)
+        result.elapsed_time = time.time() - start_time
+        return result
+
+    @staticmethod
+    def _delete_trigger_logs(session: Session, run_ids: Sequence[str]) -> int:
+        trigger_repo = SQLAlchemyWorkflowTriggerLogRepository(session)
+        return trigger_repo.delete_by_run_ids(run_ids)
+
+    @staticmethod
+    def _delete_node_executions(
+        session: Session,
+        runs: Sequence[WorkflowRun],
+    ) -> tuple[int, int]:
+        run_ids = [run.id for run in runs]
+        return DifyAPISQLAlchemyWorkflowNodeExecutionRepository.delete_by_runs(session, run_ids)
+
+    def _get_workflow_run_repo(self) -> APIWorkflowRunRepository:
+        if self.workflow_run_repo is not None:
+            return self.workflow_run_repo
+
+        from repositories.factory import DifyAPIRepositoryFactory
+
+        self.workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(
+            sessionmaker(bind=db.engine, expire_on_commit=False)
+        )
+        return self.workflow_run_repo

api/services/retention/workflow_run/restore_archived_workflow_run.py

@@ -0,0 +1,476 @@
+"""
+Restore Archived Workflow Run Service.
+
+This service restores archived workflow run data from S3-compatible storage
+back to the database.
+"""
+
+import io
+import json
+import logging
+import time
+import zipfile
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, cast
+
+import click
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+from sqlalchemy.engine import CursorResult
+from sqlalchemy.orm import DeclarativeBase, Session, sessionmaker
+
+from extensions.ext_database import db
+from libs.archive_storage import (
+    ArchiveStorage,
+    ArchiveStorageNotConfiguredError,
+    get_archive_storage,
+)
+from models.trigger import WorkflowTriggerLog
+from models.workflow import (
+    WorkflowAppLog,
+    WorkflowArchiveLog,
+    WorkflowNodeExecutionModel,
+    WorkflowNodeExecutionOffload,
+    WorkflowPause,
+    WorkflowPauseReason,
+    WorkflowRun,
+)
+from repositories.api_workflow_run_repository import APIWorkflowRunRepository
+from repositories.factory import DifyAPIRepositoryFactory
+from services.retention.workflow_run.constants import ARCHIVE_BUNDLE_NAME
+
+logger = logging.getLogger(__name__)
+
+
+# Mapping of table names to SQLAlchemy models
+TABLE_MODELS = {
+    "workflow_runs": WorkflowRun,
+    "workflow_app_logs": WorkflowAppLog,
+    "workflow_node_executions": WorkflowNodeExecutionModel,
+    "workflow_node_execution_offload": WorkflowNodeExecutionOffload,
+    "workflow_pauses": WorkflowPause,
+    "workflow_pause_reasons": WorkflowPauseReason,
+    "workflow_trigger_logs": WorkflowTriggerLog,
+}
+
+SchemaMapper = Callable[[dict[str, Any]], dict[str, Any]]
+
+SCHEMA_MAPPERS: dict[str, dict[str, SchemaMapper]] = {
+    "1.0": {},
+}
+
+
+@dataclass
+class RestoreResult:
+    """Result of restoring a single workflow run."""
+
+    run_id: str
+    tenant_id: str
+    success: bool
+    restored_counts: dict[str, int]
+    error: str | None = None
+    elapsed_time: float = 0.0
+
+
+class WorkflowRunRestore:
+    """
+    Restore archived workflow run data from storage to database.
+
+    This service reads archived data from storage and restores it to the
+    database tables. It handles idempotency by skipping records that already
+    exist in the database.
+    """
+
+    def __init__(self, dry_run: bool = False, workers: int = 1):
+        """
+        Initialize the restore service.
+
+        Args:
+            dry_run: If True, only preview without making changes
+            workers: Number of concurrent workflow runs to restore
+        """
+        self.dry_run = dry_run
+        if workers < 1:
+            raise ValueError("workers must be at least 1")
+        self.workers = workers
+        self.workflow_run_repo: APIWorkflowRunRepository | None = None
+
+    def _restore_from_run(
+        self,
+        run: WorkflowRun | WorkflowArchiveLog,
+        *,
+        session_maker: sessionmaker,
+    ) -> RestoreResult:
+        start_time = time.time()
+        run_id = run.workflow_run_id if isinstance(run, WorkflowArchiveLog) else run.id
+        created_at = run.run_created_at if isinstance(run, WorkflowArchiveLog) else run.created_at
+        result = RestoreResult(
+            run_id=run_id,
+            tenant_id=run.tenant_id,
+            success=False,
+            restored_counts={},
+        )
+
+        if not self.dry_run:
+            click.echo(
+                click.style(
+                    f"Starting restore for workflow run {run_id} (tenant={run.tenant_id})",
+                    fg="white",
+                )
+            )
+
+        try:
+            storage = get_archive_storage()
+        except ArchiveStorageNotConfiguredError as e:
+            result.error = str(e)
+            click.echo(click.style(f"Archive storage not configured: {e}", fg="red"))
+            result.elapsed_time = time.time() - start_time
+            return result
+
+        prefix = (
+            f"{run.tenant_id}/app_id={run.app_id}/year={created_at.strftime('%Y')}/"
+            f"month={created_at.strftime('%m')}/workflow_run_id={run_id}"
+        )
+        archive_key = f"{prefix}/{ARCHIVE_BUNDLE_NAME}"
+        try:
+            archive_data = storage.get_object(archive_key)
+        except FileNotFoundError:
+            result.error = f"Archive bundle not found: {archive_key}"
+            click.echo(click.style(result.error, fg="red"))
+            result.elapsed_time = time.time() - start_time
+            return result
+
+        with session_maker() as session:
+            try:
+                with zipfile.ZipFile(io.BytesIO(archive_data), mode="r") as archive:
+                    try:
+                        manifest = self._load_manifest_from_zip(archive)
+                    except ValueError as e:
+                        result.error = f"Archive bundle invalid: {e}"
+                        click.echo(click.style(result.error, fg="red"))
+                        return result
+
+                    tables = manifest.get("tables", {})
+                    schema_version = self._get_schema_version(manifest)
+                    for table_name, info in tables.items():
+                        row_count = info.get("row_count", 0)
+                        if row_count == 0:
+                            result.restored_counts[table_name] = 0
+                            continue
+
+                        if self.dry_run:
+                            result.restored_counts[table_name] = row_count
+                            continue
+
+                        member_path = f"{table_name}.jsonl"
+                        try:
+                            data = archive.read(member_path)
+                        except KeyError:
+                            click.echo(
+                                click.style(
+                                    f"  Warning: Table data not found in archive: {member_path}",
+                                    fg="yellow",
+                                )
+                            )
+                            result.restored_counts[table_name] = 0
+                            continue
+
+                        records = ArchiveStorage.deserialize_from_jsonl(data)
+                        restored = self._restore_table_records(
+                            session,
+                            table_name,
+                            records,
+                            schema_version=schema_version,
+                        )
+                        result.restored_counts[table_name] = restored
+                        if not self.dry_run:
+                            click.echo(
+                                click.style(
+                                    f"  Restored {restored}/{len(records)} records to {table_name}",
+                                    fg="white",
+                                )
+                            )
+
+                # Verify row counts match manifest
+                manifest_total = sum(info.get("row_count", 0) for info in tables.values())
+                restored_total = sum(result.restored_counts.values())
+
+                if not self.dry_run:
+                    # Note: restored count might be less than manifest count if records already exist
+                    logger.info(
+                        "Restore verification: manifest_total=%d, restored_total=%d",
+                        manifest_total,
+                        restored_total,
+                    )
+                    session.commit()
+
+                result.success = True
+                if not self.dry_run:
+                    click.echo(
+                        click.style(
+                            f"Completed restore for workflow run {run_id}: restored={result.restored_counts}",
+                            fg="green",
+                        )
+                    )
+
+            except Exception as e:
+                logger.exception("Failed to restore workflow run %s", run_id)
+                result.error = str(e)
+                session.rollback()
+                click.echo(click.style(f"Restore failed: {e}", fg="red"))
+
+        result.elapsed_time = time.time() - start_time
+        return result
+
+    def _get_workflow_run_repo(self) -> APIWorkflowRunRepository:
+        if self.workflow_run_repo is not None:
+            return self.workflow_run_repo
+
+        self.workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(
+            sessionmaker(bind=db.engine, expire_on_commit=False)
+        )
+        return self.workflow_run_repo
+
+    @staticmethod
+    def _load_manifest_from_zip(archive: zipfile.ZipFile) -> dict[str, Any]:
+        try:
+            data = archive.read("manifest.json")
+        except KeyError as e:
+            raise ValueError("manifest.json missing from archive bundle") from e
+        return json.loads(data.decode("utf-8"))
+
+    def _restore_table_records(
+        self,
+        session: Session,
+        table_name: str,
+        records: list[dict[str, Any]],
+        *,
+        schema_version: str,
+    ) -> int:
+        """
+        Restore records to a table.
+
+        Uses INSERT ... ON CONFLICT DO NOTHING for idempotency.
+
+        Args:
+            session: Database session
+            table_name: Name of the table
+            records: List of record dictionaries
+            schema_version: Archived schema version from manifest
+
+        Returns:
+            Number of records actually inserted
+        """
+        if not records:
+            return 0
+
+        model = TABLE_MODELS.get(table_name)
+        if not model:
+            logger.warning("Unknown table: %s", table_name)
+            return 0
+
+        column_names, required_columns, non_nullable_with_default = self._get_model_column_info(model)
+        unknown_fields: set[str] = set()
+
+        # Apply schema mapping, filter to current columns, then convert datetimes
+        converted_records = []
+        for record in records:
+            mapped = self._apply_schema_mapping(table_name, schema_version, record)
+            unknown_fields.update(set(mapped.keys()) - column_names)
+            filtered = {key: value for key, value in mapped.items() if key in column_names}
+            for key in non_nullable_with_default:
+                if key in filtered and filtered[key] is None:
+                    filtered.pop(key)
+            missing_required = [key for key in required_columns if key not in filtered or filtered.get(key) is None]
+            if missing_required:
+                missing_cols = ", ".join(sorted(missing_required))
+                raise ValueError(
+                    f"Missing required columns for {table_name} (schema_version={schema_version}): {missing_cols}"
+                )
+            converted = self._convert_datetime_fields(filtered, model)
+            converted_records.append(converted)
+        if unknown_fields:
+            logger.warning(
+                "Dropped unknown columns for %s (schema_version=%s): %s",
+                table_name,
+                schema_version,
+                ", ".join(sorted(unknown_fields)),
+            )
+
+        # Use INSERT ... ON CONFLICT DO NOTHING for idempotency
+        stmt = pg_insert(model).values(converted_records)
+        stmt = stmt.on_conflict_do_nothing(index_elements=["id"])
+
+        result = session.execute(stmt)
+        return cast(CursorResult, result).rowcount or 0
+
+    def _convert_datetime_fields(
+        self,
+        record: dict[str, Any],
+        model: type[DeclarativeBase] | Any,
+    ) -> dict[str, Any]:
+        """Convert ISO datetime strings to datetime objects."""
+        from sqlalchemy import DateTime
+
+        result = dict(record)
+
+        for column in model.__table__.columns:
+            if isinstance(column.type, DateTime):
+                value = result.get(column.key)
+                if isinstance(value, str):
+                    try:
+                        result[column.key] = datetime.fromisoformat(value)
+                    except ValueError:
+                        pass
+
+        return result
+
+    def _get_schema_version(self, manifest: dict[str, Any]) -> str:
+        schema_version = manifest.get("schema_version")
+        if not schema_version:
+            logger.warning("Manifest missing schema_version; defaulting to 1.0")
+            schema_version = "1.0"
+        schema_version = str(schema_version)
+        if schema_version not in SCHEMA_MAPPERS:
+            raise ValueError(f"Unsupported schema_version {schema_version}. Add a mapping before restoring.")
+        return schema_version
+
+    def _apply_schema_mapping(
+        self,
+        table_name: str,
+        schema_version: str,
+        record: dict[str, Any],
+    ) -> dict[str, Any]:
+        # Keep hook for forward/backward compatibility when schema evolves.
+        mapper = SCHEMA_MAPPERS.get(schema_version, {}).get(table_name)
+        if mapper is None:
+            return dict(record)
+        return mapper(record)
+
+    def _get_model_column_info(
+        self,
+        model: type[DeclarativeBase] | Any,
+    ) -> tuple[set[str], set[str], set[str]]:
+        columns = list(model.__table__.columns)
+        column_names = {column.key for column in columns}
+        required_columns = {
+            column.key
+            for column in columns
+            if not column.nullable
+            and column.default is None
+            and column.server_default is None
+            and not column.autoincrement
+        }
+        non_nullable_with_default = {
+            column.key
+            for column in columns
+            if not column.nullable
+            and (column.default is not None or column.server_default is not None or column.autoincrement)
+        }
+        return column_names, required_columns, non_nullable_with_default
+
+    def restore_batch(
+        self,
+        tenant_ids: list[str] | None,
+        start_date: datetime,
+        end_date: datetime,
+        limit: int = 100,
+    ) -> list[RestoreResult]:
+        """
+        Restore multiple workflow runs by time range.
+
+        Args:
+            tenant_ids: Optional tenant IDs
+            start_date: Start date filter
+            end_date: End date filter
+            limit: Maximum number of runs to restore (default: 100)
+
+        Returns:
+            List of RestoreResult objects
+        """
+        results: list[RestoreResult] = []
+        if tenant_ids is not None and not tenant_ids:
+            return results
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        repo = self._get_workflow_run_repo()
+
+        with session_maker() as session:
+            archive_logs = repo.get_archived_logs_by_time_range(
+                session=session,
+                tenant_ids=tenant_ids,
+                start_date=start_date,
+                end_date=end_date,
+                limit=limit,
+            )
+
+        click.echo(
+            click.style(
+                f"Found {len(archive_logs)} archived workflow runs to restore",
+                fg="white",
+            )
+        )
+
+        def _restore_with_session(archive_log: WorkflowArchiveLog) -> RestoreResult:
+            return self._restore_from_run(
+                archive_log,
+                session_maker=session_maker,
+            )
+
+        with ThreadPoolExecutor(max_workers=self.workers) as executor:
+            results = list(executor.map(_restore_with_session, archive_logs))
+
+        total_counts: dict[str, int] = {}
+        for result in results:
+            for table_name, count in result.restored_counts.items():
+                total_counts[table_name] = total_counts.get(table_name, 0) + count
+        success_count = sum(1 for result in results if result.success)
+
+        if self.dry_run:
+            click.echo(
+                click.style(
+                    f"[DRY RUN] Would restore {len(results)} workflow runs: totals={total_counts}",
+                    fg="yellow",
+                )
+            )
+        else:
+            click.echo(
+                click.style(
+                    f"Restored {success_count}/{len(results)} workflow runs: totals={total_counts}",
+                    fg="green",
+                )
+            )
+
+        return results
+
+    def restore_by_run_id(
+        self,
+        run_id: str,
+    ) -> RestoreResult:
+        """
+        Restore a single workflow run by run ID.
+        """
+        repo = self._get_workflow_run_repo()
+        archive_log = repo.get_archived_log_by_run_id(run_id)
+
+        if not archive_log:
+            click.echo(click.style(f"Workflow run archive {run_id} not found", fg="red"))
+            return RestoreResult(
+                run_id=run_id,
+                tenant_id="",
+                success=False,
+                restored_counts={},
+                error=f"Workflow run archive {run_id} not found",
+            )
+
+        session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)
+        result = self._restore_from_run(archive_log, session_maker=session_maker)
+        if self.dry_run and result.success:
+            click.echo(
+                click.style(
+                    f"[DRY RUN] Would restore workflow run {run_id}: totals={result.restored_counts}",
+                    fg="yellow",
+                )
+            )
+        return result

api/services/variable_truncator.py

@@ -7,7 +7,6 @@ from typing import Any, Generic, TypeAlias, TypeVar, overload
 
 from configs import dify_config
 from core.file.models import File
-from core.model_runtime.entities import PromptMessage
 from core.variables.segments import (
     ArrayFileSegment,
     ArraySegment,
@@ -288,10 +287,6 @@ class VariableTruncator(BaseTruncator):
             if isinstance(item, File):
                 truncated_value.append(item)
                 continue
-            # Handle PromptMessage types - convert to dict for truncation
-            if isinstance(item, PromptMessage):
-                truncated_value.append(item)
-                continue
             if i >= target_length:
                 return _PartResult(truncated_value, used_size, True)
             if i > 0:

api/services/workflow/entities.py

@@ -163,29 +163,3 @@ class WorkflowScheduleCFSPlanEntity(BaseModel):
 
     schedule_strategy: Strategy
     granularity: int = Field(default=-1)  # -1 means infinite
-
-
-# ========== Mention Graph Entities ==========
-
-
-class MentionParameterSchema(BaseModel):
-    """Schema for the parameter to be extracted from mention context."""
-
-    name: str = Field(description="Parameter name (e.g., 'query')")
-    type: str = Field(default="string", description="Parameter type (e.g., 'string', 'number')")
-    description: str = Field(default="", description="Parameter description for LLM")
-
-
-class MentionGraphRequest(BaseModel):
-    """Request payload for generating mention graph."""
-
-    parent_node_id: str = Field(description="ID of the parent node that uses the extracted value")
-    parameter_key: str = Field(description="Key of the parameter being extracted")
-    context_source: list[str] = Field(description="Variable selector for the context source")
-    parameter_schema: MentionParameterSchema = Field(description="Schema of the parameter to extract")
-
-
-class MentionGraphResponse(BaseModel):
-    """Response containing the generated mention graph."""
-
-    graph: Mapping[str, Any] = Field(description="Complete graph structure with nodes, edges, viewport")

api/services/workflow/mention_graph_service.py

@@ -1,143 +0,0 @@
-"""
-Service for generating Mention LLM node graph structures.
-
-This service creates graph structures containing LLM nodes configured for
-extracting values from list[PromptMessage] variables.
-"""
-
-from typing import Any
-
-from sqlalchemy.orm import Session
-
-from core.model_runtime.entities import LLMMode
-from core.workflow.enums import NodeType
-from services.model_provider_service import ModelProviderService
-from services.workflow.entities import MentionGraphRequest, MentionGraphResponse, MentionParameterSchema
-
-
-class MentionGraphService:
-    """Service for generating Mention LLM node graph structures."""
-
-    def __init__(self, session: Session):
-        self._session = session
-
-    def generate_mention_node_id(self, node_id: str, parameter_name: str) -> str:
-        """Generate mention node ID following the naming convention.
-
-        Format: {node_id}_ext_{parameter_name}
-        """
-        return f"{node_id}_ext_{parameter_name}"
-
-    def generate_mention_graph(self, tenant_id: str, request: MentionGraphRequest) -> MentionGraphResponse:
-        """Generate a complete graph structure containing a Mention LLM node.
-
-        Args:
-            tenant_id: The tenant ID for fetching default model config
-            request: The mention graph generation request
-
-        Returns:
-            Complete graph structure with nodes, edges, and viewport
-        """
-        node_id = self.generate_mention_node_id(request.parent_node_id, request.parameter_key)
-        model_config = self._get_default_model_config(tenant_id)
-        node = self._build_mention_llm_node(
-            node_id=node_id,
-            parent_node_id=request.parent_node_id,
-            context_source=request.context_source,
-            parameter_schema=request.parameter_schema,
-            model_config=model_config,
-        )
-
-        graph = {
-            "nodes": [node],
-            "edges": [],
-            "viewport": {},
-        }
-
-        return MentionGraphResponse(graph=graph)
-
-    def _get_default_model_config(self, tenant_id: str) -> dict[str, Any]:
-        """Get the default LLM model configuration for the tenant."""
-        model_provider_service = ModelProviderService()
-        default_model = model_provider_service.get_default_model_of_model_type(
-            tenant_id=tenant_id,
-            model_type="llm",
-        )
-
-        if default_model:
-            return {
-                "provider": default_model.provider.provider,
-                "name": default_model.model,
-                "mode": LLMMode.CHAT.value,
-                "completion_params": {},
-            }
-
-        # Fallback to empty config if no default model is configured
-        return {
-            "provider": "",
-            "name": "",
-            "mode": LLMMode.CHAT.value,
-            "completion_params": {},
-        }
-
-    def _build_mention_llm_node(
-        self,
-        *,
-        node_id: str,
-        parent_node_id: str,
-        context_source: list[str],
-        parameter_schema: MentionParameterSchema,
-        model_config: dict[str, Any],
-    ) -> dict[str, Any]:
-        """Build the Mention LLM node structure.
-
-        The node uses:
-        - $context in prompt_template to reference the PromptMessage list
-        - structured_output for extracting the specific parameter
-        - parent_node_id to associate with the parent node
-        """
-        prompt_template = [
-            {
-                "role": "system",
-                "text": "Extract the required parameter value from the conversation context above.",
-            },
-            {"$context": context_source},
-            {"role": "user", "text": ""},
-        ]
-
-        structured_output = {
-            "schema": {
-                "type": "object",
-                "properties": {
-                    parameter_schema.name: {
-                        "type": parameter_schema.type,
-                        "description": parameter_schema.description,
-                    }
-                },
-                "required": [parameter_schema.name],
-                "additionalProperties": False,
-            }
-        }
-
-        return {
-            "id": node_id,
-            "position": {"x": 0, "y": 0},
-            "data": {
-                "type": NodeType.LLM.value,
-                "title": f"Mention: {parameter_schema.name}",
-                "desc": f"Extract {parameter_schema.name} from conversation context",
-                "parent_node_id": parent_node_id,
-                "model": model_config,
-                "prompt_template": prompt_template,
-                "context": {
-                    "enabled": False,
-                    "variable_selector": None,
-                },
-                "vision": {
-                    "enabled": False,
-                },
-                "memory": None,
-                "structured_output_enabled": True,
-                "structured_output": structured_output,
-            },
-        }

api/services/workflow_app_service.py

@@ -7,7 +7,7 @@ from sqlalchemy import and_, func, or_, select
 from sqlalchemy.orm import Session
 
 from core.workflow.enums import WorkflowExecutionStatus
-from models import Account, App, EndUser, WorkflowAppLog, WorkflowRun
+from models import Account, App, EndUser, WorkflowAppLog, WorkflowArchiveLog, WorkflowRun
 from models.enums import AppTriggerType, CreatorUserRole
 from models.trigger import WorkflowTriggerLog
 from services.plugin.plugin_service import PluginService
@@ -173,7 +173,80 @@ class WorkflowAppService:
             "data": items,
         }
 
-    def handle_trigger_metadata(self, tenant_id: str, meta_val: str) -> dict[str, Any]:
+    def get_paginate_workflow_archive_logs(
+        self,
+        *,
+        session: Session,
+        app_model: App,
+        page: int = 1,
+        limit: int = 20,
+    ):
+        """
+        Get paginate workflow archive logs using SQLAlchemy 2.0 style.
+        """
+        stmt = select(WorkflowArchiveLog).where(
+            WorkflowArchiveLog.tenant_id == app_model.tenant_id,
+            WorkflowArchiveLog.app_id == app_model.id,
+            WorkflowArchiveLog.log_id.isnot(None),
+        )
+
+        stmt = stmt.order_by(WorkflowArchiveLog.run_created_at.desc())
+
+        count_stmt = select(func.count()).select_from(stmt.subquery())
+        total = session.scalar(count_stmt) or 0
+
+        offset_stmt = stmt.offset((page - 1) * limit).limit(limit)
+
+        logs = list(session.scalars(offset_stmt).all())
+        account_ids = {log.created_by for log in logs if log.created_by_role == CreatorUserRole.ACCOUNT}
+        end_user_ids = {log.created_by for log in logs if log.created_by_role == CreatorUserRole.END_USER}
+
+        accounts_by_id = {}
+        if account_ids:
+            accounts_by_id = {
+                account.id: account
+                for account in session.scalars(select(Account).where(Account.id.in_(account_ids))).all()
+            }
+
+        end_users_by_id = {}
+        if end_user_ids:
+            end_users_by_id = {
+                end_user.id: end_user
+                for end_user in session.scalars(select(EndUser).where(EndUser.id.in_(end_user_ids))).all()
+            }
+
+        items = []
+        for log in logs:
+            if log.created_by_role == CreatorUserRole.ACCOUNT:
+                created_by_account = accounts_by_id.get(log.created_by)
+                created_by_end_user = None
+            elif log.created_by_role == CreatorUserRole.END_USER:
+                created_by_account = None
+                created_by_end_user = end_users_by_id.get(log.created_by)
+            else:
+                created_by_account = None
+                created_by_end_user = None
+
+            items.append(
+                {
+                    "id": log.id,
+                    "workflow_run": log.workflow_run_summary,
+                    "trigger_metadata": self.handle_trigger_metadata(app_model.tenant_id, log.trigger_metadata),
+                    "created_by_account": created_by_account,
+                    "created_by_end_user": created_by_end_user,
+                    "created_at": log.log_created_at,
+                }
+            )
+
+        return {
+            "page": page,
+            "limit": limit,
+            "total": total,
+            "has_more": total > page * limit,
+            "data": items,
+        }
+
+    def handle_trigger_metadata(self, tenant_id: str, meta_val: str | None) -> dict[str, Any]:
         metadata: dict[str, Any] | None = self._safe_json_loads(meta_val)
         if not metadata:
             return {}

api/tasks/remove_app_and_related_data_task.py

@@ -9,7 +9,9 @@ from sqlalchemy import delete
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import sessionmaker
 
+from configs import dify_config
 from extensions.ext_database import db
+from libs.archive_storage import ArchiveStorageNotConfiguredError, get_archive_storage
 from models import (
     ApiToken,
     AppAnnotationHitHistory,
@@ -40,6 +42,7 @@ from models.workflow import (
     ConversationVariable,
     Workflow,
     WorkflowAppLog,
+    WorkflowArchiveLog,
 )
 from repositories.factory import DifyAPIRepositoryFactory
 
@@ -64,6 +67,9 @@ def remove_app_and_related_data_task(self, tenant_id: str, app_id: str):
         _delete_app_workflow_runs(tenant_id, app_id)
         _delete_app_workflow_node_executions(tenant_id, app_id)
         _delete_app_workflow_app_logs(tenant_id, app_id)
+        if dify_config.BILLING_ENABLED and dify_config.ARCHIVE_STORAGE_ENABLED:
+            _delete_app_workflow_archive_logs(tenant_id, app_id)
+            _delete_archived_workflow_run_files(tenant_id, app_id)
         _delete_app_conversations(tenant_id, app_id)
         _delete_app_messages(tenant_id, app_id)
         _delete_workflow_tool_providers(tenant_id, app_id)
@@ -254,6 +260,45 @@ def _delete_app_workflow_app_logs(tenant_id: str, app_id: str):
     )
 
 
+def _delete_app_workflow_archive_logs(tenant_id: str, app_id: str):
+    def del_workflow_archive_log(workflow_archive_log_id: str):
+        db.session.query(WorkflowArchiveLog).where(WorkflowArchiveLog.id == workflow_archive_log_id).delete(
+            synchronize_session=False
+        )
+
+    _delete_records(
+        """select id from workflow_archive_logs where tenant_id=:tenant_id and app_id=:app_id limit 1000""",
+        {"tenant_id": tenant_id, "app_id": app_id},
+        del_workflow_archive_log,
+        "workflow archive log",
+    )
+
+
+def _delete_archived_workflow_run_files(tenant_id: str, app_id: str):
+    prefix = f"{tenant_id}/app_id={app_id}/"
+    try:
+        archive_storage = get_archive_storage()
+    except ArchiveStorageNotConfiguredError as e:
+        logger.info("Archive storage not configured, skipping archive file cleanup: %s", e)
+        return
+
+    try:
+        keys = archive_storage.list_objects(prefix)
+    except Exception:
+        logger.exception("Failed to list archive files for app %s", app_id)
+        return
+
+    deleted = 0
+    for key in keys:
+        try:
+            archive_storage.delete_object(key)
+            deleted += 1
+        except Exception:
+            logger.exception("Failed to delete archive object %s", key)
+
+    logger.info("Deleted %s archive objects for app %s", deleted, app_id)
+
+
 def _delete_app_conversations(tenant_id: str, app_id: str):
     def del_conversation(conversation_id: str):
         db.session.query(PinnedConversation).where(PinnedConversation.conversation_id == conversation_id).delete(

api/tests/fixtures/file output schema.yml

@@ -1,181 +0,0 @@
-app:
-  description: ''
-  icon: 🤖
-  icon_background: '#FFEAD5'
-  mode: advanced-chat
-  name: file output schema
-  use_icon_as_answer_icon: false
-dependencies:
-- current_identifier: null
-  type: marketplace
-  value:
-    marketplace_plugin_unique_identifier: langgenius/openai:0.2.3@5a7f82fa86e28332ad51941d0b491c1e8a38ead539656442f7bf4c6129cd15fa
-    version: null
-kind: app
-version: 0.5.0
-workflow:
-  conversation_variables: []
-  environment_variables: []
-  features:
-    file_upload:
-      allowed_file_extensions:
-      - .JPG
-      - .JPEG
-      - .PNG
-      - .GIF
-      - .WEBP
-      - .SVG
-      allowed_file_types:
-      - image
-      allowed_file_upload_methods:
-      - remote_url
-      - local_file
-      enabled: true
-      fileUploadConfig:
-        attachment_image_file_size_limit: 2
-        audio_file_size_limit: 50
-        batch_count_limit: 5
-        file_size_limit: 15
-        file_upload_limit: 10
-        image_file_batch_limit: 10
-        image_file_size_limit: 10
-        single_chunk_attachment_limit: 10
-        video_file_size_limit: 100
-        workflow_file_upload_limit: 10
-      number_limits: 3
-    opening_statement: ''
-    retriever_resource:
-      enabled: true
-    sensitive_word_avoidance:
-      enabled: false
-    speech_to_text:
-      enabled: false
-    suggested_questions: []
-    suggested_questions_after_answer:
-      enabled: false
-    text_to_speech:
-      enabled: false
-      language: ''
-      voice: ''
-  graph:
-    edges:
-    - data:
-        sourceType: start
-        targetType: llm
-      id: 1768292241666-llm
-      source: '1768292241666'
-      sourceHandle: source
-      target: llm
-      targetHandle: target
-      type: custom
-    - data:
-        sourceType: llm
-        targetType: answer
-      id: llm-answer
-      source: llm
-      sourceHandle: source
-      target: answer
-      targetHandle: target
-      type: custom
-    nodes:
-    - data:
-        selected: false
-        title: User Input
-        type: start
-        variables: []
-      height: 73
-      id: '1768292241666'
-      position:
-        x: 80
-        y: 282
-      positionAbsolute:
-        x: 80
-        y: 282
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    - data:
-        context:
-          enabled: false
-          variable_selector: []
-        memory:
-          query_prompt_template: '{{#sys.query#}}
-
-
-            {{#sys.files#}}'
-          role_prefix:
-            assistant: ''
-            user: ''
-          window:
-            enabled: false
-            size: 10
-        model:
-          completion_params:
-            temperature: 0.7
-          mode: chat
-          name: gpt-4o-mini
-          provider: langgenius/openai/openai
-        prompt_template:
-        - id: e30d75d7-7d85-49ec-be3c-3baf7f6d3c5a
-          role: system
-          text: ''
-        selected: false
-        structured_output:
-          schema:
-            additionalProperties: false
-            properties:
-              image:
-                description: File ID (UUID) of the selected image
-                format: dify-file-ref
-                type: string
-            required:
-            - image
-            type: object
-        structured_output_enabled: true
-        title: LLM
-        type: llm
-        vision:
-          configs:
-            detail: high
-            variable_selector:
-            - sys
-            - files
-          enabled: true
-      height: 88
-      id: llm
-      position:
-        x: 380
-        y: 282
-      positionAbsolute:
-        x: 380
-        y: 282
-      selected: false
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    - data:
-        answer: '{{#llm.structured_output.image#}}'
-        selected: false
-        title: Answer
-        type: answer
-        variables: []
-      height: 103
-      id: answer
-      position:
-        x: 680
-        y: 282
-      positionAbsolute:
-        x: 680
-        y: 282
-      selected: true
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    viewport:
-      x: -149
-      y: 97.5
-      zoom: 1
-  rag_pipeline_variables: []

api/tests/fixtures/pav-test-extraction.yml

@@ -1,307 +0,0 @@
-app:
-  description: Test for variable extraction feature
-  icon: 🤖
-  icon_background: '#FFEAD5'
-  mode: advanced-chat
-  name: pav-test-extraction
-  use_icon_as_answer_icon: false
-dependencies:
-- current_identifier: null
-  type: marketplace
-  value:
-    marketplace_plugin_unique_identifier: langgenius/google:0.0.8@3efcf55ffeef9d0f77715e0afb23534952ae0cb385c051d0637e86d71199d1a6
-    version: null
-- current_identifier: null
-  type: marketplace
-  value:
-    marketplace_plugin_unique_identifier: langgenius/openai:0.2.3@5a7f82fa86e28332ad51941d0b491c1e8a38ead539656442f7bf4c6129cd15fa
-    version: null
-- current_identifier: null
-  type: marketplace
-  value:
-    marketplace_plugin_unique_identifier: langgenius/tongyi:0.1.16@d8bffbe45418f0c117fb3393e5e40e61faee98f9a2183f062e5a280e74b15d21
-    version: null
-kind: app
-version: 0.5.0
-workflow:
-  conversation_variables: []
-  environment_variables: []
-  features:
-    file_upload:
-      allowed_file_extensions:
-      - .JPG
-      - .JPEG
-      - .PNG
-      - .GIF
-      - .WEBP
-      - .SVG
-      allowed_file_types:
-      - image
-      allowed_file_upload_methods:
-      - local_file
-      - remote_url
-      enabled: false
-      image:
-        enabled: false
-        number_limits: 3
-        transfer_methods:
-        - local_file
-        - remote_url
-      number_limits: 3
-    opening_statement: 你好！我是一个搜索助手，请告诉我你想搜索什么内容。
-    retriever_resource:
-      enabled: true
-    sensitive_word_avoidance:
-      enabled: false
-    speech_to_text:
-      enabled: false
-    suggested_questions: []
-    suggested_questions_after_answer:
-      enabled: false
-    text_to_speech:
-      enabled: false
-      language: ''
-      voice: ''
-  graph:
-    edges:
-    - data:
-        sourceType: start
-        targetType: llm
-      id: 1767773675796-llm
-      source: '1767773675796'
-      sourceHandle: source
-      target: llm
-      targetHandle: target
-      type: custom
-    - data:
-        isInIteration: false
-        isInLoop: false
-        sourceType: llm
-        targetType: tool
-      id: llm-source-1767773709491-target
-      source: llm
-      sourceHandle: source
-      target: '1767773709491'
-      targetHandle: target
-      type: custom
-      zIndex: 0
-    - data:
-        isInIteration: false
-        isInLoop: false
-        sourceType: tool
-        targetType: answer
-      id: tool-source-answer-target
-      source: '1767773709491'
-      sourceHandle: source
-      target: answer
-      targetHandle: target
-      type: custom
-      zIndex: 0
-    nodes:
-    - data:
-        selected: false
-        title: User Input
-        type: start
-        variables: []
-      height: 73
-      id: '1767773675796'
-      position:
-        x: 80
-        y: 282
-      positionAbsolute:
-        x: 80
-        y: 282
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    - data:
-        context:
-          enabled: false
-          variable_selector: []
-        memory:
-          mode: node
-          query_prompt_template: '{{#sys.query#}}'
-          role_prefix:
-            assistant: ''
-            user: ''
-          window:
-            enabled: true
-            size: 10
-        model:
-          completion_params:
-            temperature: 0.7
-          mode: chat
-          name: qwen-max
-          provider: langgenius/tongyi/tongyi
-        prompt_template:
-        - id: 11d06d15-914a-4915-a5b1-0e35ab4fba51
-          role: system
-          text: '你是一个智能搜索助手。用户会告诉你他们想搜索的内容。
-
-            请与用户进行对话，了解他们的搜索需求。
-
-            当用户明确表达了想要搜索的内容后，你可以回复"好的，我来帮你搜索"。
-
-            '
-        selected: false
-        title: LLM
-        type: llm
-        vision:
-          enabled: false
-      height: 88
-      id: llm
-      position:
-        x: 380
-        y: 282
-      positionAbsolute:
-        x: 380
-        y: 282
-      selected: false
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    - data:
-        is_team_authorization: true
-        paramSchemas:
-        - auto_generate: null
-          default: null
-          form: llm
-          human_description:
-            en_US: used for searching
-            ja_JP: used for searching
-            pt_BR: used for searching
-            zh_Hans: 用于搜索网页内容
-          label:
-            en_US: Query string
-            ja_JP: Query string
-            pt_BR: Query string
-            zh_Hans: 查询语句
-          llm_description: key words for searching
-          max: null
-          min: null
-          name: query
-          options: []
-          placeholder: null
-          precision: null
-          required: true
-          scope: null
-          template: null
-          type: string
-        params:
-          query: ''
-        plugin_id: langgenius/google
-        plugin_unique_identifier: langgenius/google:0.0.8@3efcf55ffeef9d0f77715e0afb23534952ae0cb385c051d0637e86d71199d1a6
-        provider_icon: http://localhost:5001/console/api/workspaces/current/plugin/icon?tenant_id=7217e801-f6f5-49ec-8103-d7de97a4b98f&filename=1c5871163478957bac64c3fe33d72d003f767497d921c74b742aad27a8344a74.svg
-        provider_id: langgenius/google/google
-        provider_name: langgenius/google/google
-        provider_type: builtin
-        selected: false
-        title: GoogleSearch
-        tool_configurations: {}
-        tool_description: A tool for performing a Google SERP search and extracting
-          snippets and webpages.Input should be a search query.
-        tool_label: GoogleSearch
-        tool_name: google_search
-        tool_node_version: '2'
-        tool_parameters:
-          query:
-            type: mention
-            value: '{{@llm.context@}}请从对话历史中提取用户想要搜索的关键词，只返回关键词本身'
-            mention_config:
-              extractor_node_id: 1767773709491_ext_query
-              output_selector:
-              - structured_output
-              - query
-              null_strategy: use_default
-              default_value: ''
-        type: tool
-      height: 52
-      id: '1767773709491'
-      position:
-        x: 682
-        y: 282
-      positionAbsolute:
-        x: 682
-        y: 282
-      selected: false
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    - data:
-        context:
-          enabled: false
-          variable_selector: []
-        model:
-          completion_params:
-            temperature: 0.7
-          mode: chat
-          name: gpt-4o-mini
-          provider: langgenius/openai/openai
-        parent_node_id: '1767773709491'
-        prompt_template:
-        - $context:
-          - llm
-          - context
-          id: 75d58e22-dc59-40c8-ba6f-aeb28f4f305a
-        - id: 18ba6710-77f5-47f4-b144-9191833bb547
-          role: user
-          text: 请从对话历史中提取用户想要搜索的关键词，只返回关键词本身，不要返回其他内容
-        selected: false
-        structured_output:
-          schema:
-            additionalProperties: false
-            properties:
-              query:
-                description: 搜索的关键词
-                type: string
-            required:
-            - query
-            type: object
-        structured_output_enabled: true
-        title: 提取搜索关键词
-        type: llm
-        vision:
-          enabled: false
-      height: 88
-      id: 1767773709491_ext_query
-      position:
-        x: 531
-        y: 382
-      positionAbsolute:
-        x: 531
-        y: 382
-      selected: true
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    - data:
-        answer: '搜索结果：
-
-          {{#1767773709491.text#}}
-
-          '
-        selected: false
-        title: Answer
-        type: answer
-      height: 103
-      id: answer
-      position:
-        x: 984
-        y: 282
-      positionAbsolute:
-        x: 984
-        y: 282
-      selected: false
-      sourcePosition: right
-      targetPosition: left
-      type: custom
-      width: 242
-    viewport:
-      x: -151
-      y: 123
-      zoom: 1
-  rag_pipeline_variables: []

api/tests/unit_tests/controllers/console/app/test_xss_prevention.py

@@ -1,254 +0,0 @@
-"""
-Unit tests for XSS prevention in App payloads.
-
-This test module validates that HTML tags, JavaScript, and other potentially
-dangerous content are rejected in App names and descriptions.
-"""
-
-import pytest
-
-from controllers.console.app.app import CopyAppPayload, CreateAppPayload, UpdateAppPayload
-
-
-class TestXSSPreventionUnit:
-    """Unit tests for XSS prevention in App payloads."""
-
-    def test_create_app_valid_names(self):
-        """Test CreateAppPayload with valid app names."""
-        # Normal app names should be valid
-        valid_names = [
-            "My App",
-            "Test App 123",
-            "App with - dash",
-            "App with _ underscore",
-            "App with + plus",
-            "App with () parentheses",
-            "App with [] brackets",
-            "App with {} braces",
-            "App with ! exclamation",
-            "App with @ at",
-            "App with # hash",
-            "App with $ dollar",
-            "App with % percent",
-            "App with ^ caret",
-            "App with & ampersand",
-            "App with * asterisk",
-            "Unicode: 测试应用",
-            "Emoji: 🤖",
-            "Mixed: Test 测试 123",
-        ]
-
-        for name in valid_names:
-            payload = CreateAppPayload(
-                name=name,
-                mode="chat",
-            )
-            assert payload.name == name
-
-    def test_create_app_xss_script_tags(self):
-        """Test CreateAppPayload rejects script tags."""
-        xss_payloads = [
-            "<script>alert(document.cookie)</script>",
-            "<Script>alert(1)</Script>",
-            "<SCRIPT>alert('XSS')</SCRIPT>",
-            "<script>alert(String.fromCharCode(88,83,83))</script>",
-            "<script src='evil.js'></script>",
-            "<script>document.location='http://evil.com'</script>",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_iframe_tags(self):
-        """Test CreateAppPayload rejects iframe tags."""
-        xss_payloads = [
-            "<iframe src='evil.com'></iframe>",
-            "<Iframe srcdoc='<script>alert(1)</script>'></iframe>",
-            "<IFRAME src='javascript:alert(1)'></iframe>",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_javascript_protocol(self):
-        """Test CreateAppPayload rejects javascript: protocol."""
-        xss_payloads = [
-            "javascript:alert(1)",
-            "JAVASCRIPT:alert(1)",
-            "JavaScript:alert(document.cookie)",
-            "javascript:void(0)",
-            "javascript://comment%0Aalert(1)",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_svg_onload(self):
-        """Test CreateAppPayload rejects SVG with onload."""
-        xss_payloads = [
-            "<svg onload=alert(1)>",
-            "<SVG ONLOAD=alert(1)>",
-            "<svg/x/onload=alert(1)>",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_event_handlers(self):
-        """Test CreateAppPayload rejects HTML event handlers."""
-        xss_payloads = [
-            "<div onclick=alert(1)>",
-            "<img onerror=alert(1)>",
-            "<body onload=alert(1)>",
-            "<input onfocus=alert(1)>",
-            "<a onmouseover=alert(1)>",
-            "<DIV ONCLICK=alert(1)>",
-            "<img src=x onerror=alert(1)>",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_object_embed(self):
-        """Test CreateAppPayload rejects object and embed tags."""
-        xss_payloads = [
-            "<object data='evil.swf'></object>",
-            "<embed src='evil.swf'>",
-            "<OBJECT data='javascript:alert(1)'></OBJECT>",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_link_javascript(self):
-        """Test CreateAppPayload rejects link tags with javascript."""
-        xss_payloads = [
-            "<link href='javascript:alert(1)'>",
-            "<LINK HREF='javascript:alert(1)'>",
-        ]
-
-        for name in xss_payloads:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_xss_in_description(self):
-        """Test CreateAppPayload rejects XSS in description."""
-        xss_descriptions = [
-            "<script>alert(1)</script>",
-            "javascript:alert(1)",
-            "<img onerror=alert(1)>",
-        ]
-
-        for description in xss_descriptions:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(
-                    name="Valid Name",
-                    mode="chat",
-                    description=description,
-                )
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_create_app_valid_descriptions(self):
-        """Test CreateAppPayload with valid descriptions."""
-        valid_descriptions = [
-            "A simple description",
-            "Description with < and > symbols",
-            "Description with & ampersand",
-            "Description with 'quotes' and \"double quotes\"",
-            "Description with / slashes",
-            "Description with \\ backslashes",
-            "Description with ; semicolons",
-            "Unicode: 这是一个描述",
-            "Emoji: 🎉🚀",
-        ]
-
-        for description in valid_descriptions:
-            payload = CreateAppPayload(
-                name="Valid App Name",
-                mode="chat",
-                description=description,
-            )
-            assert payload.description == description
-
-    def test_create_app_none_description(self):
-        """Test CreateAppPayload with None description."""
-        payload = CreateAppPayload(
-            name="Valid App Name",
-            mode="chat",
-            description=None,
-        )
-        assert payload.description is None
-
-    def test_update_app_xss_prevention(self):
-        """Test UpdateAppPayload also prevents XSS."""
-        xss_names = [
-            "<script>alert(1)</script>",
-            "javascript:alert(1)",
-            "<img onerror=alert(1)>",
-        ]
-
-        for name in xss_names:
-            with pytest.raises(ValueError) as exc_info:
-                UpdateAppPayload(name=name)
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_update_app_valid_names(self):
-        """Test UpdateAppPayload with valid names."""
-        payload = UpdateAppPayload(name="Valid Updated Name")
-        assert payload.name == "Valid Updated Name"
-
-    def test_copy_app_xss_prevention(self):
-        """Test CopyAppPayload also prevents XSS."""
-        xss_names = [
-            "<script>alert(1)</script>",
-            "javascript:alert(1)",
-            "<img onerror=alert(1)>",
-        ]
-
-        for name in xss_names:
-            with pytest.raises(ValueError) as exc_info:
-                CopyAppPayload(name=name)
-            assert "invalid characters or patterns" in str(exc_info.value).lower()
-
-    def test_copy_app_valid_names(self):
-        """Test CopyAppPayload with valid names."""
-        payload = CopyAppPayload(name="Valid Copy Name")
-        assert payload.name == "Valid Copy Name"
-
-    def test_copy_app_none_name(self):
-        """Test CopyAppPayload with None name (should be allowed)."""
-        payload = CopyAppPayload(name=None)
-        assert payload.name is None
-
-    def test_edge_case_angle_brackets_content(self):
-        """Test that angle brackets with actual content are rejected."""
-        # Angle brackets without valid HTML-like patterns should be checked
-        # The regex pattern <.*?on\w+\s*= should catch event handlers
-        # But let's verify other patterns too
-
-        # Valid: angle brackets used as symbols (not matched by our patterns)
-        # Our patterns specifically look for dangerous constructs
-
-        # Invalid: actual HTML tags with event handlers
-        invalid_names = [
-            "<div onclick=xss>",
-            "<img src=x onerror=alert(1)>",
-        ]
-
-        for name in invalid_names:
-            with pytest.raises(ValueError) as exc_info:
-                CreateAppPayload(name=name, mode="chat")
-            assert "invalid characters or patterns" in str(exc_info.value).lower()

api/tests/unit_tests/controllers/console/datasets/test_datasets_document_download.py

@@ -0,0 +1,430 @@
+"""
+Unit tests for the dataset document download endpoint.
+
+These tests validate that the controller returns a signed download URL for
+upload-file documents, and rejects unsupported or missing file cases.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from collections import UserDict
+from io import BytesIO
+from types import SimpleNamespace
+from typing import Any
+from zipfile import ZipFile
+
+import pytest
+from flask import Flask
+from werkzeug.exceptions import Forbidden, NotFound
+
+
+@pytest.fixture
+def app() -> Flask:
+    """Create a minimal Flask app for request-context based controller tests."""
+    app = Flask(__name__)
+    app.config["TESTING"] = True
+    return app
+
+
+@pytest.fixture
+def datasets_document_module(monkeypatch: pytest.MonkeyPatch):
+    """
+    Reload `controllers.console.datasets.datasets_document` with lightweight decorators.
+
+    We patch auth / setup / rate-limit decorators to no-ops so we can unit test the
+    controller logic without requiring the full console stack.
+    """
+
+    from controllers.console import console_ns, wraps
+    from libs import login
+
+    def _noop(func):  # type: ignore[no-untyped-def]
+        return func
+
+    # Bypass login/setup/account checks in unit tests.
+    monkeypatch.setattr(login, "login_required", _noop)
+    monkeypatch.setattr(wraps, "setup_required", _noop)
+    monkeypatch.setattr(wraps, "account_initialization_required", _noop)
+
+    # Bypass billing-related decorators used by other endpoints in this module.
+    monkeypatch.setattr(wraps, "cloud_edition_billing_resource_check", lambda *_args, **_kwargs: (lambda f: f))
+    monkeypatch.setattr(wraps, "cloud_edition_billing_rate_limit_check", lambda *_args, **_kwargs: (lambda f: f))
+
+    # Avoid Flask-RESTX route registration side effects during import.
+    def _noop_route(*_args, **_kwargs):  # type: ignore[override]
+        def _decorator(cls):
+            return cls
+
+        return _decorator
+
+    monkeypatch.setattr(console_ns, "route", _noop_route)
+
+    module_name = "controllers.console.datasets.datasets_document"
+    sys.modules.pop(module_name, None)
+    return importlib.import_module(module_name)
+
+
+def _mock_user(*, is_dataset_editor: bool = True) -> SimpleNamespace:
+    """Build a minimal user object compatible with dataset permission checks."""
+    return SimpleNamespace(is_dataset_editor=is_dataset_editor, id="user-123")
+
+
+def _mock_document(
+    *,
+    document_id: str,
+    tenant_id: str,
+    data_source_type: str,
+    upload_file_id: str | None,
+) -> SimpleNamespace:
+    """Build a minimal document object used by the controller."""
+    data_source_info_dict: dict[str, Any] | None = None
+    if upload_file_id is not None:
+        data_source_info_dict = {"upload_file_id": upload_file_id}
+    else:
+        data_source_info_dict = {}
+
+    return SimpleNamespace(
+        id=document_id,
+        tenant_id=tenant_id,
+        data_source_type=data_source_type,
+        data_source_info_dict=data_source_info_dict,
+    )
+
+
+def _wire_common_success_mocks(
+    *,
+    module,
+    monkeypatch: pytest.MonkeyPatch,
+    current_tenant_id: str,
+    document_tenant_id: str,
+    data_source_type: str,
+    upload_file_id: str | None,
+    upload_file_exists: bool,
+    signed_url: str,
+) -> None:
+    """Patch controller dependencies to create a deterministic test environment."""
+    import services.dataset_service as dataset_service_module
+
+    # Make `current_account_with_tenant()` return a known user + tenant id.
+    monkeypatch.setattr(module, "current_account_with_tenant", lambda: (_mock_user(), current_tenant_id))
+
+    # Return a dataset object and allow permission checks to pass.
+    monkeypatch.setattr(module.DatasetService, "get_dataset", lambda _dataset_id: SimpleNamespace(id="ds-1"))
+    monkeypatch.setattr(module.DatasetService, "check_dataset_permission", lambda *_args, **_kwargs: None)
+
+    # Return a document that will be validated inside DocumentResource.get_document.
+    document = _mock_document(
+        document_id="doc-1",
+        tenant_id=document_tenant_id,
+        data_source_type=data_source_type,
+        upload_file_id=upload_file_id,
+    )
+    monkeypatch.setattr(module.DocumentService, "get_document", lambda *_args, **_kwargs: document)
+
+    # Mock UploadFile lookup via FileService batch helper.
+    upload_files_by_id: dict[str, Any] = {}
+    if upload_file_exists and upload_file_id is not None:
+        upload_files_by_id[str(upload_file_id)] = SimpleNamespace(id=str(upload_file_id))
+    monkeypatch.setattr(module.FileService, "get_upload_files_by_ids", lambda *_args, **_kwargs: upload_files_by_id)
+
+    # Mock signing helper so the returned URL is deterministic.
+    monkeypatch.setattr(dataset_service_module.file_helpers, "get_signed_file_url", lambda **_kwargs: signed_url)
+
+
+def _mock_send_file(obj, **kwargs):  # type: ignore[no-untyped-def]
+    """Return a lightweight representation of `send_file(...)` for unit tests."""
+
+    class _ResponseMock(UserDict):
+        def __init__(self, sent_file: object, send_file_kwargs: dict[str, object]) -> None:
+            super().__init__({"_sent_file": sent_file, "_send_file_kwargs": send_file_kwargs})
+            self._on_close: object | None = None
+
+        def call_on_close(self, func):  # type: ignore[no-untyped-def]
+            self._on_close = func
+            return func
+
+    return _ResponseMock(obj, kwargs)
+
+
+def test_batch_download_zip_returns_send_file(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure batch ZIP download returns a zip attachment via `send_file`."""
+
+    # Arrange common permission mocks.
+    monkeypatch.setattr(datasets_document_module, "current_account_with_tenant", lambda: (_mock_user(), "tenant-123"))
+    monkeypatch.setattr(
+        datasets_document_module.DatasetService, "get_dataset", lambda _dataset_id: SimpleNamespace(id="ds-1")
+    )
+    monkeypatch.setattr(
+        datasets_document_module.DatasetService, "check_dataset_permission", lambda *_args, **_kwargs: None
+    )
+
+    # Two upload-file documents, each referencing an UploadFile.
+    doc1 = _mock_document(
+        document_id="11111111-1111-1111-1111-111111111111",
+        tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id="file-1",
+    )
+    doc2 = _mock_document(
+        document_id="22222222-2222-2222-2222-222222222222",
+        tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id="file-2",
+    )
+    monkeypatch.setattr(
+        datasets_document_module.DocumentService,
+        "get_documents_by_ids",
+        lambda *_args, **_kwargs: [doc1, doc2],
+    )
+    monkeypatch.setattr(
+        datasets_document_module.FileService,
+        "get_upload_files_by_ids",
+        lambda *_args, **_kwargs: {
+            "file-1": SimpleNamespace(id="file-1", name="a.txt", key="k1"),
+            "file-2": SimpleNamespace(id="file-2", name="b.txt", key="k2"),
+        },
+    )
+
+    # Mock storage streaming content.
+    import services.file_service as file_service_module
+
+    monkeypatch.setattr(file_service_module.storage, "load", lambda _key, stream=True: [b"hello"])
+
+    # Replace send_file used by the controller to avoid a real Flask response object.
+    monkeypatch.setattr(datasets_document_module, "send_file", _mock_send_file)
+
+    # Act
+    with app.test_request_context(
+        "/datasets/ds-1/documents/download-zip",
+        method="POST",
+        json={"document_ids": ["11111111-1111-1111-1111-111111111111", "22222222-2222-2222-2222-222222222222"]},
+    ):
+        api = datasets_document_module.DocumentBatchDownloadZipApi()
+        result = api.post(dataset_id="ds-1")
+
+    # Assert: we returned via send_file with correct mime type and attachment.
+    assert result["_send_file_kwargs"]["mimetype"] == "application/zip"
+    assert result["_send_file_kwargs"]["as_attachment"] is True
+    assert isinstance(result["_send_file_kwargs"]["download_name"], str)
+    assert result["_send_file_kwargs"]["download_name"].endswith(".zip")
+    # Ensure our cleanup hook is registered and execute it to avoid temp file leaks in unit tests.
+    assert getattr(result, "_on_close", None) is not None
+    result._on_close()  # type: ignore[attr-defined]
+
+
+def test_batch_download_zip_response_is_openable_zip(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure the real Flask `send_file` response body is a valid ZIP that can be opened."""
+
+    # Arrange: same controller mocks as the lightweight send_file test, but we keep the real `send_file`.
+    monkeypatch.setattr(datasets_document_module, "current_account_with_tenant", lambda: (_mock_user(), "tenant-123"))
+    monkeypatch.setattr(
+        datasets_document_module.DatasetService, "get_dataset", lambda _dataset_id: SimpleNamespace(id="ds-1")
+    )
+    monkeypatch.setattr(
+        datasets_document_module.DatasetService, "check_dataset_permission", lambda *_args, **_kwargs: None
+    )
+
+    doc1 = _mock_document(
+        document_id="33333333-3333-3333-3333-333333333333",
+        tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id="file-1",
+    )
+    doc2 = _mock_document(
+        document_id="44444444-4444-4444-4444-444444444444",
+        tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id="file-2",
+    )
+    monkeypatch.setattr(
+        datasets_document_module.DocumentService,
+        "get_documents_by_ids",
+        lambda *_args, **_kwargs: [doc1, doc2],
+    )
+    monkeypatch.setattr(
+        datasets_document_module.FileService,
+        "get_upload_files_by_ids",
+        lambda *_args, **_kwargs: {
+            "file-1": SimpleNamespace(id="file-1", name="a.txt", key="k1"),
+            "file-2": SimpleNamespace(id="file-2", name="b.txt", key="k2"),
+        },
+    )
+
+    # Stream distinct bytes per key so we can verify both ZIP entries.
+    import services.file_service as file_service_module
+
+    monkeypatch.setattr(
+        file_service_module.storage, "load", lambda key, stream=True: [b"one"] if key == "k1" else [b"two"]
+    )
+
+    # Act
+    with app.test_request_context(
+        "/datasets/ds-1/documents/download-zip",
+        method="POST",
+        json={"document_ids": ["33333333-3333-3333-3333-333333333333", "44444444-4444-4444-4444-444444444444"]},
+    ):
+        api = datasets_document_module.DocumentBatchDownloadZipApi()
+        response = api.post(dataset_id="ds-1")
+
+    # Assert: response body is a valid ZIP and contains the expected entries.
+    response.direct_passthrough = False
+    data = response.get_data()
+    response.close()
+
+    with ZipFile(BytesIO(data), mode="r") as zf:
+        assert zf.namelist() == ["a.txt", "b.txt"]
+        assert zf.read("a.txt") == b"one"
+        assert zf.read("b.txt") == b"two"
+
+
+def test_batch_download_zip_rejects_non_upload_file_document(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure batch ZIP download rejects non upload-file documents."""
+
+    monkeypatch.setattr(datasets_document_module, "current_account_with_tenant", lambda: (_mock_user(), "tenant-123"))
+    monkeypatch.setattr(
+        datasets_document_module.DatasetService, "get_dataset", lambda _dataset_id: SimpleNamespace(id="ds-1")
+    )
+    monkeypatch.setattr(
+        datasets_document_module.DatasetService, "check_dataset_permission", lambda *_args, **_kwargs: None
+    )
+
+    doc = _mock_document(
+        document_id="55555555-5555-5555-5555-555555555555",
+        tenant_id="tenant-123",
+        data_source_type="website_crawl",
+        upload_file_id="file-1",
+    )
+    monkeypatch.setattr(
+        datasets_document_module.DocumentService,
+        "get_documents_by_ids",
+        lambda *_args, **_kwargs: [doc],
+    )
+
+    with app.test_request_context(
+        "/datasets/ds-1/documents/download-zip",
+        method="POST",
+        json={"document_ids": ["55555555-5555-5555-5555-555555555555"]},
+    ):
+        api = datasets_document_module.DocumentBatchDownloadZipApi()
+        with pytest.raises(NotFound):
+            api.post(dataset_id="ds-1")
+
+
+def test_document_download_returns_url_for_upload_file_document(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure upload-file documents return a `{url}` JSON payload."""
+
+    _wire_common_success_mocks(
+        module=datasets_document_module,
+        monkeypatch=monkeypatch,
+        current_tenant_id="tenant-123",
+        document_tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id="file-123",
+        upload_file_exists=True,
+        signed_url="https://example.com/signed",
+    )
+
+    # Build a request context then call the resource method directly.
+    with app.test_request_context("/datasets/ds-1/documents/doc-1/download", method="GET"):
+        api = datasets_document_module.DocumentDownloadApi()
+        result = api.get(dataset_id="ds-1", document_id="doc-1")
+
+    assert result == {"url": "https://example.com/signed"}
+
+
+def test_document_download_rejects_non_upload_file_document(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure non-upload documents raise 404 (no file to download)."""
+
+    _wire_common_success_mocks(
+        module=datasets_document_module,
+        monkeypatch=monkeypatch,
+        current_tenant_id="tenant-123",
+        document_tenant_id="tenant-123",
+        data_source_type="website_crawl",
+        upload_file_id="file-123",
+        upload_file_exists=True,
+        signed_url="https://example.com/signed",
+    )
+
+    with app.test_request_context("/datasets/ds-1/documents/doc-1/download", method="GET"):
+        api = datasets_document_module.DocumentDownloadApi()
+        with pytest.raises(NotFound):
+            api.get(dataset_id="ds-1", document_id="doc-1")
+
+
+def test_document_download_rejects_missing_upload_file_id(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure missing `upload_file_id` raises 404."""
+
+    _wire_common_success_mocks(
+        module=datasets_document_module,
+        monkeypatch=monkeypatch,
+        current_tenant_id="tenant-123",
+        document_tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id=None,
+        upload_file_exists=False,
+        signed_url="https://example.com/signed",
+    )
+
+    with app.test_request_context("/datasets/ds-1/documents/doc-1/download", method="GET"):
+        api = datasets_document_module.DocumentDownloadApi()
+        with pytest.raises(NotFound):
+            api.get(dataset_id="ds-1", document_id="doc-1")
+
+
+def test_document_download_rejects_when_upload_file_record_missing(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure missing UploadFile row raises 404."""
+
+    _wire_common_success_mocks(
+        module=datasets_document_module,
+        monkeypatch=monkeypatch,
+        current_tenant_id="tenant-123",
+        document_tenant_id="tenant-123",
+        data_source_type="upload_file",
+        upload_file_id="file-123",
+        upload_file_exists=False,
+        signed_url="https://example.com/signed",
+    )
+
+    with app.test_request_context("/datasets/ds-1/documents/doc-1/download", method="GET"):
+        api = datasets_document_module.DocumentDownloadApi()
+        with pytest.raises(NotFound):
+            api.get(dataset_id="ds-1", document_id="doc-1")
+
+
+def test_document_download_rejects_tenant_mismatch(
+    app: Flask, datasets_document_module, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Ensure tenant mismatch is rejected by the shared `get_document()` permission check."""
+
+    _wire_common_success_mocks(
+        module=datasets_document_module,
+        monkeypatch=monkeypatch,
+        current_tenant_id="tenant-123",
+        document_tenant_id="tenant-999",
+        data_source_type="upload_file",
+        upload_file_id="file-123",
+        upload_file_exists=True,
+        signed_url="https://example.com/signed",
+    )
+
+    with app.test_request_context("/datasets/ds-1/documents/doc-1/download", method="GET"):
+        api = datasets_document_module.DocumentDownloadApi()
+        with pytest.raises(Forbidden):
+            api.get(dataset_id="ds-1", document_id="doc-1")

api/tests/unit_tests/core/file/test_file_manager.py

@@ -1,182 +0,0 @@
-"""Tests for file_manager module, specifically multimodal content handling."""
-
-from unittest.mock import patch
-
-from core.file import File, FileTransferMethod, FileType
-from core.file.file_manager import (
-    _encode_file_ref,
-    restore_multimodal_content,
-    to_prompt_message_content,
-)
-from core.model_runtime.entities.message_entities import ImagePromptMessageContent
-
-
-class TestEncodeFileRef:
-    """Tests for _encode_file_ref function."""
-
-    def test_encodes_local_file(self):
-        """Local file should be encoded as 'local:id'."""
-        file = File(
-            tenant_id="t",
-            type=FileType.IMAGE,
-            transfer_method=FileTransferMethod.LOCAL_FILE,
-            related_id="abc123",
-            storage_key="key",
-        )
-        assert _encode_file_ref(file) == "local:abc123"
-
-    def test_encodes_tool_file(self):
-        """Tool file should be encoded as 'tool:id'."""
-        file = File(
-            tenant_id="t",
-            type=FileType.IMAGE,
-            transfer_method=FileTransferMethod.TOOL_FILE,
-            related_id="xyz789",
-            storage_key="key",
-        )
-        assert _encode_file_ref(file) == "tool:xyz789"
-
-    def test_encodes_remote_url(self):
-        """Remote URL should be encoded as 'remote:url'."""
-        file = File(
-            tenant_id="t",
-            type=FileType.IMAGE,
-            transfer_method=FileTransferMethod.REMOTE_URL,
-            remote_url="https://example.com/image.png",
-            storage_key="",
-        )
-        assert _encode_file_ref(file) == "remote:https://example.com/image.png"
-
-
-class TestToPromptMessageContent:
-    """Tests for to_prompt_message_content function with file_ref field."""
-
-    @patch("core.file.file_manager.dify_config")
-    @patch("core.file.file_manager._get_encoded_string")
-    def test_includes_file_ref(self, mock_get_encoded, mock_config):
-        """Generated content should include file_ref field."""
-        mock_config.MULTIMODAL_SEND_FORMAT = "base64"
-        mock_get_encoded.return_value = "base64data"
-
-        file = File(
-            id="test-message-file-id",
-            tenant_id="test-tenant",
-            type=FileType.IMAGE,
-            transfer_method=FileTransferMethod.LOCAL_FILE,
-            related_id="test-related-id",
-            remote_url=None,
-            extension=".png",
-            mime_type="image/png",
-            filename="test.png",
-            storage_key="test-key",
-        )
-
-        result = to_prompt_message_content(file)
-
-        assert isinstance(result, ImagePromptMessageContent)
-        assert result.file_ref == "local:test-related-id"
-        assert result.base64_data == "base64data"
-
-
-class TestRestoreMultimodalContent:
-    """Tests for restore_multimodal_content function."""
-
-    def test_returns_content_unchanged_when_no_file_ref(self):
-        """Content without file_ref should pass through unchanged."""
-        content = ImagePromptMessageContent(
-            format="png",
-            base64_data="existing-data",
-            mime_type="image/png",
-            file_ref=None,
-        )
-
-        result = restore_multimodal_content(content)
-
-        assert result.base64_data == "existing-data"
-
-    def test_returns_content_unchanged_when_already_has_data(self):
-        """Content that already has base64_data should not be reloaded."""
-        content = ImagePromptMessageContent(
-            format="png",
-            base64_data="existing-data",
-            mime_type="image/png",
-            file_ref="local:file-id",
-        )
-
-        result = restore_multimodal_content(content)
-
-        assert result.base64_data == "existing-data"
-
-    def test_returns_content_unchanged_when_already_has_url(self):
-        """Content that already has url should not be reloaded."""
-        content = ImagePromptMessageContent(
-            format="png",
-            url="https://example.com/image.png",
-            mime_type="image/png",
-            file_ref="local:file-id",
-        )
-
-        result = restore_multimodal_content(content)
-
-        assert result.url == "https://example.com/image.png"
-
-    @patch("core.file.file_manager.dify_config")
-    @patch("core.file.file_manager._build_file_from_ref")
-    @patch("core.file.file_manager._to_url")
-    def test_restores_url_from_file_ref(self, mock_to_url, mock_build_file, mock_config):
-        """Content should be restored from file_ref when url is empty (url mode)."""
-        mock_config.MULTIMODAL_SEND_FORMAT = "url"
-        mock_build_file.return_value = "mock_file"
-        mock_to_url.return_value = "https://restored-url.com/image.png"
-
-        content = ImagePromptMessageContent(
-            format="png",
-            base64_data="",
-            url="",
-            mime_type="image/png",
-            filename="test.png",
-            file_ref="local:test-file-id",
-        )
-
-        result = restore_multimodal_content(content)
-
-        assert result.url == "https://restored-url.com/image.png"
-        mock_build_file.assert_called_once()
-
-    @patch("core.file.file_manager.dify_config")
-    @patch("core.file.file_manager._build_file_from_ref")
-    @patch("core.file.file_manager._get_encoded_string")
-    def test_restores_base64_from_file_ref(self, mock_get_encoded, mock_build_file, mock_config):
-        """Content should be restored as base64 when in base64 mode."""
-        mock_config.MULTIMODAL_SEND_FORMAT = "base64"
-        mock_build_file.return_value = "mock_file"
-        mock_get_encoded.return_value = "restored-base64-data"
-
-        content = ImagePromptMessageContent(
-            format="png",
-            base64_data="",
-            url="",
-            mime_type="image/png",
-            filename="test.png",
-            file_ref="local:test-file-id",
-        )
-
-        result = restore_multimodal_content(content)
-
-        assert result.base64_data == "restored-base64-data"
-        mock_build_file.assert_called_once()
-
-    def test_handles_invalid_file_ref_gracefully(self):
-        """Invalid file_ref format should be handled gracefully."""
-        content = ImagePromptMessageContent(
-            format="png",
-            base64_data="",
-            url="",
-            mime_type="image/png",
-            file_ref="invalid_format_no_colon",
-        )
-
-        result = restore_multimodal_content(content)
-
-        # Should return unchanged on error
-        assert result.base64_data == ""

api/tests/unit_tests/core/llm_generator/output_parser/test_file_ref.py

@@ -1,269 +0,0 @@
-"""
-Unit tests for file reference detection and conversion.
-"""
-
-import uuid
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from core.file import File, FileTransferMethod, FileType
-from core.llm_generator.output_parser.file_ref import (
-    FILE_REF_FORMAT,
-    convert_file_refs_in_output,
-    detect_file_ref_fields,
-    is_file_ref_property,
-)
-from core.variables.segments import ArrayFileSegment, FileSegment
-
-
-class TestIsFileRefProperty:
-    """Tests for is_file_ref_property function."""
-
-    def test_valid_file_ref(self):
-        schema = {"type": "string", "format": FILE_REF_FORMAT}
-        assert is_file_ref_property(schema) is True
-
-    def test_invalid_type(self):
-        schema = {"type": "number", "format": FILE_REF_FORMAT}
-        assert is_file_ref_property(schema) is False
-
-    def test_missing_format(self):
-        schema = {"type": "string"}
-        assert is_file_ref_property(schema) is False
-
-    def test_wrong_format(self):
-        schema = {"type": "string", "format": "uuid"}
-        assert is_file_ref_property(schema) is False
-
-
-class TestDetectFileRefFields:
-    """Tests for detect_file_ref_fields function."""
-
-    def test_simple_file_ref(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-            },
-        }
-        paths = detect_file_ref_fields(schema)
-        assert paths == ["image"]
-
-    def test_multiple_file_refs(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-                "document": {"type": "string", "format": FILE_REF_FORMAT},
-                "name": {"type": "string"},
-            },
-        }
-        paths = detect_file_ref_fields(schema)
-        assert set(paths) == {"image", "document"}
-
-    def test_array_of_file_refs(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "files": {
-                    "type": "array",
-                    "items": {"type": "string", "format": FILE_REF_FORMAT},
-                },
-            },
-        }
-        paths = detect_file_ref_fields(schema)
-        assert paths == ["files[*]"]
-
-    def test_nested_file_ref(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "image": {"type": "string", "format": FILE_REF_FORMAT},
-                    },
-                },
-            },
-        }
-        paths = detect_file_ref_fields(schema)
-        assert paths == ["data.image"]
-
-    def test_no_file_refs(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "name": {"type": "string"},
-                "count": {"type": "number"},
-            },
-        }
-        paths = detect_file_ref_fields(schema)
-        assert paths == []
-
-    def test_empty_schema(self):
-        schema = {}
-        paths = detect_file_ref_fields(schema)
-        assert paths == []
-
-    def test_mixed_schema(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "query": {"type": "string"},
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-                "documents": {
-                    "type": "array",
-                    "items": {"type": "string", "format": FILE_REF_FORMAT},
-                },
-            },
-        }
-        paths = detect_file_ref_fields(schema)
-        assert set(paths) == {"image", "documents[*]"}
-
-
-class TestConvertFileRefsInOutput:
-    """Tests for convert_file_refs_in_output function."""
-
-    @pytest.fixture
-    def mock_file(self):
-        """Create a mock File object with all required attributes."""
-        file = MagicMock(spec=File)
-        file.type = FileType.IMAGE
-        file.transfer_method = FileTransferMethod.TOOL_FILE
-        file.related_id = "test-related-id"
-        file.remote_url = None
-        file.tenant_id = "tenant_123"
-        file.id = None
-        file.filename = "test.png"
-        file.extension = ".png"
-        file.mime_type = "image/png"
-        file.size = 1024
-        file.dify_model_identity = "__dify__file__"
-        return file
-
-    @pytest.fixture
-    def mock_build_from_mapping(self, mock_file):
-        """Mock the build_from_mapping function."""
-        with patch("core.llm_generator.output_parser.file_ref.build_from_mapping") as mock:
-            mock.return_value = mock_file
-            yield mock
-
-    def test_convert_simple_file_ref(self, mock_build_from_mapping, mock_file):
-        file_id = str(uuid.uuid4())
-        output = {"image": file_id}
-        schema = {
-            "type": "object",
-            "properties": {
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-            },
-        }
-
-        result = convert_file_refs_in_output(output, schema, "tenant_123")
-
-        # Result should be wrapped in FileSegment
-        assert isinstance(result["image"], FileSegment)
-        assert result["image"].value == mock_file
-        mock_build_from_mapping.assert_called_once_with(
-            mapping={"transfer_method": "tool_file", "tool_file_id": file_id},
-            tenant_id="tenant_123",
-        )
-
-    def test_convert_array_of_file_refs(self, mock_build_from_mapping, mock_file):
-        file_id1 = str(uuid.uuid4())
-        file_id2 = str(uuid.uuid4())
-        output = {"files": [file_id1, file_id2]}
-        schema = {
-            "type": "object",
-            "properties": {
-                "files": {
-                    "type": "array",
-                    "items": {"type": "string", "format": FILE_REF_FORMAT},
-                },
-            },
-        }
-
-        result = convert_file_refs_in_output(output, schema, "tenant_123")
-
-        # Result should be wrapped in ArrayFileSegment
-        assert isinstance(result["files"], ArrayFileSegment)
-        assert list(result["files"].value) == [mock_file, mock_file]
-        assert mock_build_from_mapping.call_count == 2
-
-    def test_no_conversion_without_file_refs(self):
-        output = {"name": "test", "count": 5}
-        schema = {
-            "type": "object",
-            "properties": {
-                "name": {"type": "string"},
-                "count": {"type": "number"},
-            },
-        }
-
-        result = convert_file_refs_in_output(output, schema, "tenant_123")
-
-        assert result == {"name": "test", "count": 5}
-
-    def test_invalid_uuid_returns_none(self):
-        output = {"image": "not-a-valid-uuid"}
-        schema = {
-            "type": "object",
-            "properties": {
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-            },
-        }
-
-        result = convert_file_refs_in_output(output, schema, "tenant_123")
-
-        assert result["image"] is None
-
-    def test_file_not_found_returns_none(self):
-        file_id = str(uuid.uuid4())
-        output = {"image": file_id}
-        schema = {
-            "type": "object",
-            "properties": {
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-            },
-        }
-
-        with patch("core.llm_generator.output_parser.file_ref.build_from_mapping") as mock:
-            mock.side_effect = ValueError("File not found")
-            result = convert_file_refs_in_output(output, schema, "tenant_123")
-
-        assert result["image"] is None
-
-    def test_preserves_non_file_fields(self, mock_build_from_mapping, mock_file):
-        file_id = str(uuid.uuid4())
-        output = {"query": "search term", "image": file_id, "count": 10}
-        schema = {
-            "type": "object",
-            "properties": {
-                "query": {"type": "string"},
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-                "count": {"type": "number"},
-            },
-        }
-
-        result = convert_file_refs_in_output(output, schema, "tenant_123")
-
-        assert result["query"] == "search term"
-        assert isinstance(result["image"], FileSegment)
-        assert result["image"].value == mock_file
-        assert result["count"] == 10
-
-    def test_does_not_modify_original_output(self, mock_build_from_mapping, mock_file):
-        file_id = str(uuid.uuid4())
-        original = {"image": file_id}
-        output = dict(original)
-        schema = {
-            "type": "object",
-            "properties": {
-                "image": {"type": "string", "format": FILE_REF_FORMAT},
-            },
-        }
-
-        convert_file_refs_in_output(output, schema, "tenant_123")
-
-        # Original should still contain the string ID
-        assert original["image"] == file_id

api/tests/unit_tests/core/plugin/test_plugin_runtime.py

@@ -346,6 +346,7 @@ class TestPluginRuntimeErrorHandling:
         mock_response.status_code = 200
         invoke_error = {
             "error_type": "InvokeRateLimitError",
+            "message": "Rate limit exceeded",
             "args": {"description": "Rate limit exceeded"},
         }
         error_message = json.dumps({"error_type": "PluginInvokeError", "message": json.dumps(invoke_error)})
@@ -364,6 +365,7 @@ class TestPluginRuntimeErrorHandling:
         mock_response.status_code = 200
         invoke_error = {
             "error_type": "InvokeAuthorizationError",
+            "message": "Invalid credentials",
             "args": {"description": "Invalid credentials"},
         }
         error_message = json.dumps({"error_type": "PluginInvokeError", "message": json.dumps(invoke_error)})
@@ -382,6 +384,7 @@ class TestPluginRuntimeErrorHandling:
         mock_response.status_code = 200
         invoke_error = {
             "error_type": "InvokeBadRequestError",
+            "message": "Invalid parameters",
             "args": {"description": "Invalid parameters"},
         }
         error_message = json.dumps({"error_type": "PluginInvokeError", "message": json.dumps(invoke_error)})
@@ -400,6 +403,7 @@ class TestPluginRuntimeErrorHandling:
         mock_response.status_code = 200
         invoke_error = {
             "error_type": "InvokeConnectionError",
+            "message": "Connection to external service failed",
             "args": {"description": "Connection to external service failed"},
         }
         error_message = json.dumps({"error_type": "PluginInvokeError", "message": json.dumps(invoke_error)})
@@ -418,6 +422,7 @@ class TestPluginRuntimeErrorHandling:
         mock_response.status_code = 200
         invoke_error = {
             "error_type": "InvokeServerUnavailableError",
+            "message": "Service temporarily unavailable",
             "args": {"description": "Service temporarily unavailable"},
         }
         error_message = json.dumps({"error_type": "PluginInvokeError", "message": json.dumps(invoke_error)})

api/tests/unit_tests/core/workflow/graph_engine/event_management/test_event_handlers.py

@@ -25,12 +25,6 @@ class _StubErrorHandler:
     """Minimal error handler stub for tests."""
 
 
-class _StubNodeData:
-    """Simple node data stub with is_extractor_node property."""
-
-    is_extractor_node = False
-
-
 class _StubNode:
     """Simple node stub exposing the attributes needed by the state manager."""
 
@@ -42,7 +36,6 @@ class _StubNode:
         self.error_strategy = None
         self.retry_config = RetryConfig()
         self.retry = False
-        self.node_data = _StubNodeData()
 
 
 def _build_event_handler(node_id: str) -> tuple[EventHandler, EventManager, GraphExecution]: