fred-capability-documents 4.4.3__py3-none-any.whl

fred_capability_documents/document_summarize/capability.py

@@ -0,0 +1,382 @@
+# Copyright Thales 2026
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+`DocumentSummarizeCapability` (RFC §3, §10) — on-demand document summarization.
+
+Why this module exists:
+- `summarize_document` used to be bundled inside `document_access`, but its
+  invocation is decided purely by the LLM from the tool docstring — there is
+  no query-shaped config condition (unlike `list_document_tree`'s
+  `team_documents`) that tells the runtime when the tool should even exist
+  for an agent. This capability is its own admin-gated, per-agent opt-in (an
+  agent selecting `document_access` does NOT get this tool for free) — the
+  admission control that governs it today.
+- commonly paired with `document_access` (its `list_document_tree` /
+  `search_documents_using_vectorization` hits are the usual source of the
+  `document_uid` this tool's caller needs), but there is no runtime coupling:
+  the uid can equally come from the conversation's attached-files list.
+
+`hitl_specs()` (RFC §5.4) gates `summarize_document` behind human approval by
+default — defense in depth alongside admission control (`ADMIN_GATED` below):
+admission decides whether an agent can select this tool at all, HITL decides
+whether each individual call still needs a human's proceed/cancel. The gate
+is configurable per agent instance via `require_confirmation` (default
+`True`), not hardcoded — an admin who has already reviewed and trusts this
+agent's usage can turn it off. (#2179, ReAct V2 HITL resume dead-ending in a
+409, blocked this until it was fixed — see `RUNTIME-EXECUTION-CONTRACT.md`.)
+
+Doctrine (RFC §3.5, §3.8, §10) — same as `document_access`:
+- the capability reaches the platform ONLY through the typed
+  `RuntimeServices.document_summarize` port; the per-turn binding and the raw
+  access token NEVER enter `CapabilityContext`
+- the tool signature exposes ONLY LLM arguments; scope and identity reach the
+  tool through the middleware closure, never the tool schema
+
+Identifier hygiene (hard rule, shared with `document_access`): the
+`document_uid` argument is an internal working identifier for the agent's own
+tool calls. The docstring instructs the model to NEVER repeat it to the end
+user — answers refer to documents by display name only.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+
+from fred_sdk.contracts.capability import (
+    AgentCapability,
+    CapabilityContext,
+    CapabilityManifest,
+    EmptyModel,
+    HitlGateRequest,
+    HitlSpec,
+)
+from fred_sdk.contracts.context import (
+    ToolContentBlock,
+    ToolContentKind,
+    ToolInvocationResult,
+)
+from fred_sdk.contracts.models import FieldSpec, UIHints
+from fred_sdk.contracts.runtime import (
+    DocumentScopeRefusedError,
+    DocumentSummaryResult,
+    unwrap_run_stop_error,
+)
+from langchain_core.tools import BaseTool, tool
+from pydantic import BaseModel, Field
+
+from fred_capability_documents.document_read_common import document_scope_refusal
+
+_KF_SERVICE = "Knowledge Flow"
+
+# Built-in default summary length when neither the caller (the LLM) nor the
+# capability config specifies one.
+DEFAULT_SUMMARIZE_MAX_CHARS = 5000
+# Wire bounds of the Knowledge Flow endpoint's `max_chars` validation — clamp
+# client-side so an out-of-range LLM value degrades gracefully instead of 422ing.
+_SUMMARIZE_MAX_CHARS_BOUNDS = (200, 20_000)
+
+
+def _clamp(value: int, bounds: tuple[int, int]) -> int:
+    low, high = bounds
+    return max(low, min(value, high))
+
+
+def resolve_summarize_max_chars(cap: int | None, requested: int | None) -> int:
+    """
+    Resolve the effective summary length from the configured cap and the
+    caller's request.
+
+    The per-agent cap (`summarize_max_chars` config) is both the default (when
+    the caller asks for nothing) and a hard upper bound on whatever the caller
+    requests; without one, the built-in default applies and the caller's
+    request is honored verbatim (within wire bounds).
+    """
+
+    default = cap if cap is not None else DEFAULT_SUMMARIZE_MAX_CHARS
+    effective = requested if requested is not None else default
+    if cap is not None:
+        effective = min(effective, cap)
+    return _clamp(effective, _SUMMARIZE_MAX_CHARS_BOUNDS)
+
+
+def _document_tool_failure(
+    *,
+    tool_ref: str,
+    action: str,
+    exc: Exception,
+    elapsed_s: float,
+    document_uid: str | None = None,
+) -> tuple[str, ToolInvocationResult]:
+    """Turn any document tool-call failure into a non-empty, actionable error
+    message plus an ``is_error=True`` artifact.
+
+    The v2 ReAct runtime surfaces ``ToolInvocationResult.is_error`` directly to
+    the user (and suppresses LLM hallucination), so a failing tool MUST return
+    such a result instead of raising — a raised exception is re-raised by the
+    default ``ToolNode`` handler, which leaves the tool call pending in the
+    trace and yields an empty error detail to the UI.
+
+    Transport detail (timeout, HTTP status) arrives via the SDK-typed
+    `DocumentPortCallError` attributes the adapters stamp — this module never
+    imports the adapter's HTTP stack.
+    """
+
+    err_type = type(exc).__name__
+    raw = str(exc).strip()
+    timed_out = bool(getattr(exc, "timed_out", False))
+    status_code = getattr(exc, "status_code", None)
+
+    if timed_out:
+        cause = f"the {_KF_SERVICE} service timed out after {elapsed_s:.0f}s"
+    elif status_code is not None:
+        cause = f"the {_KF_SERVICE} service returned HTTP {status_code}"
+    else:
+        cause = f"the {_KF_SERVICE} service call failed after {elapsed_s:.0f}s"
+
+    target = f" (document_uid={document_uid})" if document_uid else ""
+    detail = f": {raw}" if raw else ""
+    message = f"Could not {action}{target}: {cause} [{err_type}{detail}]."
+    return message, ToolInvocationResult(
+        tool_ref=tool_ref,
+        is_error=True,
+        blocks=(ToolContentBlock(kind=ToolContentKind.TEXT, text=message),),
+    )
+
+
+class DocumentSummarizeConfig(BaseModel):
+    """
+    Agent-creation / stored config of the document-summarize capability
+    (RFC §3.2, #2177).
+    """
+
+    # Per-agent default AND hard cap for summarize_document's summary length
+    # (chars). None = built-in default, caller's request honored verbatim.
+    summarize_max_chars: int | None = Field(default=None, ge=200, le=20_000)
+    # Whether summarize_document pauses for human proceed/cancel before each
+    # call (RFC §5.4). Defaults to on — an admin who trusts this agent's
+    # usage can turn it off per instance; see `hitl_specs()`.
+    require_confirmation: bool = True
+
+
+class DocumentSummarizeCapability(
+    AgentCapability[DocumentSummarizeConfig, DocumentSummarizeConfig, EmptyModel]
+):
+    """
+    On-demand document summarization, wired through the `document_summarize`
+    port. Single tool, no chat controls, no turn options — see the module
+    docstring for the admission/execution split with `document_access`.
+    """
+
+    manifest = CapabilityManifest(
+        id="document_summarize",
+        # Pre-GA: version stays 0.1.0 while the platform has not shipped —
+        # config-surface changes land without bumps.
+        version="0.1.0",
+        name="capability.document_summarize.name",
+        description="capability.document_summarize.description",
+        icon="summarize",
+        config_fields=[
+            FieldSpec(
+                key="require_confirmation",
+                type="boolean",
+                title="capability.document_summarize.fields.require_confirmation.title",
+                description="capability.document_summarize.fields.require_confirmation.description",
+                default=True,
+                ui=UIHints(group="safety"),
+            ),
+            FieldSpec(
+                key="summarize_max_chars",
+                type="integer",
+                title="capability.document_summarize.fields.summarize_max_chars.title",
+                description="capability.document_summarize.fields.summarize_max_chars.description",
+                min=200,
+                max=20_000,
+                ui=UIHints(group="retrieval", advanced=True),
+            ),
+        ],
+        # No new chat part / side panel / router / owned table.
+        # team_scope intentionally left at the class default (ADMIN_GATED,
+        # RFC §7, §8.3): unlike document_access's baseline search/tree, this
+        # tool has no config-shaped trigger a user can reason about — a team
+        # admin must explicitly enable it before any agent in that team can
+        # even select it.
+    )
+    ConfigModel = DocumentSummarizeConfig
+
+    def tools(
+        self,
+        ctx: CapabilityContext[DocumentSummarizeConfig, EmptyModel],
+    ) -> Sequence[BaseTool]:
+        """
+        Build the single summarize tool, bound to the turn's typed context
+        (RFC §3.2, §5). `AgentCapability.middleware()`'s default wraps this
+        for `create_agent()`; no ReAct-loop-specific hook is needed.
+
+        Return-convention note:
+        kept as `@tool(..., response_format="content_and_artifact")` returning
+        a `(content, ToolInvocationResult)` tuple — see `document_access`'s
+        `tools()` docstring for the full rationale; identical constraint here.
+        """
+
+        config = ctx.config
+        services = ctx.services
+        summarize_cap = config.summarize_max_chars
+
+        @tool("summarize_document", response_format="content_and_artifact")
+        async def summarize_document(
+            document_uid: str,
+            instruction: str | None = None,
+            max_chars: int | None = None,
+        ) -> tuple[str, ToolInvocationResult]:
+            """Generate a fresh, on-demand summary of one document by its uid.
+
+            Use this when you need to understand a document's content in depth —
+            e.g. to decide whether it's relevant, or to extract specific
+            information — without pulling its full text into your own context. A
+            fresh model reads the whole document (using map-reduce for large
+            documents) and returns just the summary.
+
+            `document_uid` MUST be the document's opaque uid, not its name or
+            title. Get it from a prior search_documents_using_vectorization
+            hit's 'uid' field, from list_document_tree (the value shown in
+            '[...]' after each document name), or from the conversation's
+            attached-files list (the bracketed value after the file name). If
+            you only know a document's name, resolve its uid with one of those
+            first — never pass the name here. The uid is an internal working
+            identifier for YOUR tool calls only: NEVER repeat it in your answer
+            to the user — always refer to the document by its display name.
+
+            Pass `instruction` to steer the summary: focus area, what to look
+            for, audience, tone, desired length — e.g. "focus on financial risks
+            and list every action item". Without it, you get a generic abstract.
+
+            `max_chars` bounds the returned summary length; raise it for a more
+            detailed summary, lower it for a terse one. Leave it unset to use
+            the agent's configured default. The agent may also impose a hard
+            maximum, in which case a larger request is clamped down to it.
+            """
+
+            port = services.document_summarize
+            if port is None:
+                raise RuntimeError(
+                    "document_summarize: RuntimeServices.document_summarize is "
+                    "not available on this execution path."
+                )
+
+            effective_max_chars = resolve_summarize_max_chars(summarize_cap, max_chars)
+            started = time.monotonic()
+            try:
+                result: DocumentSummaryResult = await port.summarize(
+                    document_uid,
+                    instruction=instruction,
+                    max_chars=effective_max_chars,
+                )
+            except DocumentScopeRefusedError as exc:
+                return document_scope_refusal(
+                    tool_ref="summarize_document",
+                    action="summarize the document",
+                    exc=exc,
+                )
+            except Exception as exc:
+                run_stop = unwrap_run_stop_error(exc)
+                if run_stop is not None:
+                    raise run_stop from None
+                message, artifact = _document_tool_failure(
+                    tool_ref="summarize_document",
+                    action="summarize the document",
+                    exc=exc,
+                    elapsed_s=time.monotonic() - started,
+                    document_uid=document_uid,
+                )
+                # 403/404 almost always means the model passed something that
+                # is not a document uid — a file NAME, a stale/foreign uid, or
+                # a FOLDER's tag id from a list_document_tree folder line
+                # (observed live, issue #2244) — the backend fails closed on
+                # unknown resources. Tell the model how to recover instead of
+                # letting it give up and echo the error.
+                if getattr(exc, "status_code", None) in (403, 404):
+                    message += (
+                        " Likely cause: document_uid was not a document's "
+                        "opaque uid. If you passed a file name, resolve the "
+                        "uid first: it is in the conversation's attached-files "
+                        "list (the bracketed value after the file name), in a "
+                        "search hit's 'uid' field, or on a DOCUMENT line of "
+                        "list_document_tree. If you took the id from a FOLDER "
+                        "line (it ends with '/', id shown as [folder:...]), "
+                        "that is a folder id, not a document — summarize each "
+                        "document listed under that folder instead. Then call "
+                        "summarize_document again with a real document uid; "
+                        "if other documents already summarized fine, continue "
+                        "with those results. Do not repeat the uid to the "
+                        "user."
+                    )
+                    # CAPAB-02: `_document_tool_failure` already baked the
+                    # (shorter) pre-hint message into `artifact.blocks`; the
+                    # recovery hint appended above must reach `blocks` too, or
+                    # a Graph agent — which keeps only the artifact half of
+                    # this return — loses exactly the guidance a model needs
+                    # to self-correct and retry.
+                    artifact = artifact.model_copy(
+                        update={
+                            "blocks": (
+                                ToolContentBlock(
+                                    kind=ToolContentKind.TEXT, text=message
+                                ),
+                            )
+                        }
+                    )
+                return message, artifact
+            # `blocks` carries the same summary text as `content` (CAPAB-02):
+            # a Graph agent's plain-dict invocation keeps only the artifact
+            # half of a `content_and_artifact` return.
+            artifact = ToolInvocationResult(
+                tool_ref="summarize_document",
+                blocks=(
+                    ToolContentBlock(kind=ToolContentKind.TEXT, text=result.summary),
+                ),
+            )
+            return result.summary, artifact
+
+        return [summarize_document]
+
+    def hitl_specs(self) -> Sequence[HitlSpec]:
+        """
+        `summarize_document` is gated by default, per instance configurable
+        (#2177) — `require=False` defers to `_confirmation_required` instead
+        of hardcoding the decision, the same `when`-predicate mechanism
+        `document_access` already relies on for its own conditional scope
+        fields (RFC §5.4). The predicate reads the resolved instance config
+        fresh at gate time (`request.context.config`), so it always reflects
+        the CURRENT `require_confirmation` value, not whatever was true when
+        `hitl_specs()` itself was called (assembly time, no per-turn context
+        yet).
+        """
+
+        return [
+            HitlSpec(
+                tool="summarize_document",
+                require=False,
+                when=_confirmation_required,
+            )
+        ]
+
+
+def _confirmation_required(request: HitlGateRequest) -> bool:
+    """Whether this agent instance still wants a human's proceed/cancel
+    before `summarize_document` runs — the resolved `require_confirmation`
+    config value (default `True`, see `DocumentSummarizeConfig`)."""
+
+    return bool(request.context.config.require_confirmation)

fred_capability_documents/document_verbatim/__init__.py

@@ -0,0 +1,27 @@
+# Copyright Thales 2026
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+`DocumentVerbatimCapability` (DOCREAD-01) — verbatim, paginated document read.
+
+Installing fred-capability-documents registers it via the `fred.capabilities` entry point
+(`document_verbatim`). Pairs with `document_extract` over the shared
+`document_markdown` port; see `document_read_common`.
+"""
+
+from __future__ import annotations
+
+from .capability import DocumentVerbatimCapability
+
+__all__ = ["DocumentVerbatimCapability"]

fred_capability_documents/document_verbatim/capability.py

@@ -0,0 +1,128 @@
+# Copyright Thales 2026
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+`DocumentVerbatimCapability` (DOCREAD-01) — read a document's exact text
+verbatim, one bounded page at a time, through the `document_markdown` port.
+
+Half of the document-reading pair (see `document_read_common`). This capability
+answers positional/literal questions ("what does the first paragraph say?",
+"read section 3") — distinct from `document_extract` (exhaustive enumeration by
+criterion) and `document_summarize` (a lossy overview). All three can coexist on
+one agent; each tool's docstring draws the boundary so the model picks the right
+one.
+
+Installing fred-capability-documents registers it via the `fred.capabilities` entry point
+(`document_verbatim`); it is `ADMIN_GATED` (class default), a per-agent opt-in a
+team admin must enable.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from fred_sdk.contracts.capability import (
+    AgentCapability,
+    CapabilityContext,
+    CapabilityManifest,
+    EmptyModel,
+)
+from fred_sdk.contracts.context import ToolInvocationResult
+from fred_sdk.contracts.models import FieldSpec, UIHints
+from langchain_core.tools import BaseTool, tool
+
+from fred_capability_documents.document_read_common import (
+    DocumentReadConfig,
+    read_document_page,
+    resolve_page_max_chars,
+)
+
+
+class DocumentVerbatimCapability(
+    AgentCapability[DocumentReadConfig, DocumentReadConfig, EmptyModel]
+):
+    """Verbatim, paginated document read. Single tool, no chat controls, no turn
+    options, no HITL (read-only)."""
+
+    manifest = CapabilityManifest(
+        id="document_verbatim",
+        # Pre-GA: version stays 0.1.0 while the platform has not shipped.
+        version="0.1.0",
+        name="capability.document_verbatim.name",
+        description="capability.document_verbatim.description",
+        icon="description",
+        config_fields=[
+            FieldSpec(
+                key="page_max_chars",
+                type="integer",
+                title="capability.document_verbatim.fields.page_max_chars.title",
+                description="capability.document_verbatim.fields.page_max_chars.description",
+                min=200,
+                max=50_000,
+                ui=UIHints(group="retrieval", advanced=True),
+            ),
+        ],
+        # team_scope left at the class default (ADMIN_GATED).
+    )
+    ConfigModel = DocumentReadConfig
+
+    def tools(
+        self,
+        ctx: CapabilityContext[DocumentReadConfig, EmptyModel],
+    ) -> Sequence[BaseTool]:
+        config = ctx.config
+        services = ctx.services
+        page_cap = config.page_max_chars
+
+        @tool("read_document", response_format="content_and_artifact")
+        async def read_document(
+            document_uid: str,
+            offset: int = 0,
+            max_chars: int | None = None,
+        ) -> tuple[str, ToolInvocationResult]:
+            """Read a document's exact text VERBATIM, one page at a time.
+
+            Use this to see what a document literally says at a given position —
+            e.g. "what does the first paragraph say?", "read the introduction",
+            "show me section 3" — or to read a whole short document. Returns the
+            document's text unchanged, NOT a summary.
+
+            When to use a different tool instead:
+            - for a short, lossy overview of the whole document → summarize_document;
+            - to enumerate EVERY item matching a criterion across the whole
+              document ("all the requirements") → extract_from_document.
+
+            `document_uid` MUST be the document's opaque uid, not its name — get
+            it from a search hit's 'uid', the document tree, or the
+            conversation's attached-files list. The uid is an internal working
+            identifier for YOUR tool calls only: NEVER repeat it in your answer;
+            always refer to the document by its display name.
+
+            `offset` is the character position to start from (0 = the very
+            beginning). `max_chars` bounds this page (leave unset for the agent's
+            default). If the returned result says more text remains, call again
+            with the next offset it gives you to keep reading.
+            """
+
+            effective = resolve_page_max_chars(page_cap, max_chars)
+            return await read_document_page(
+                port=services.document_markdown,
+                tool_ref="read_document",
+                document_uid=document_uid,
+                offset=offset,
+                max_chars=effective,
+                exhaustive=False,
+            )
+
+        return [read_document]

fred_capability_documents-4.4.3.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: fred-capability-documents
+Version: 4.4.3
+Summary: Fred agent capabilities over the Knowledge Flow document ports: summarize, similarity, label search, extract, verbatim read.
+Author-email: Thales <noreply@thalesgroup.com>
+License: Apache-2.0
+Project-URL: Homepage, https://site.fredlab.dev
+Project-URL: Repository, https://github.com/ThalesGroup/fred
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fred-core>=4.4.3
+Requires-Dist: fred-sdk[agents]>=4.4.3
+Requires-Dist: pydantic<3.0.0,>=2.7.0
+Requires-Dist: langchain-core>=0.3.0
+Provides-Extra: dev
+Requires-Dist: bandit>=1.8.6; extra == "dev"
+Requires-Dist: basedpyright==1.31.0; extra == "dev"
+Requires-Dist: detect-secrets>=1.5.0; extra == "dev"
+Requires-Dist: pytest>=8.4.2; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.2.0; extra == "dev"
+Requires-Dist: pytest-cov>=6.2.1; extra == "dev"
+Requires-Dist: pytest-socket>=0.7.0; extra == "dev"
+Requires-Dist: ruff<0.16,>=0.15.22; extra == "dev"
+
+# fred-capability-documents
+
+Fred agent capabilities over the Knowledge Flow document ports. One package,
+one `fred.capabilities` entry point per capability, each admin-gated and
+independently grantable by a team admin.
+
+## Capabilities
+
+- **`document_summarize`** — on-demand summary of one document
+  (`RuntimeServices.document_summarize`).
+- **`document_similarity`** — targeted document-to-document comparison
+  (`RuntimeServices.document_similarity`).
+- **`document_label_search`** — exhaustive, paginated resolution of a
+  business label to documents (`RuntimeServices.document_tree`).
+- **`document_verbatim`** — verbatim, paginated read of one document
+  (`RuntimeServices.document_markdown`).
+- **`document_extract`** — exhaustive extraction from one document
+  (`RuntimeServices.document_extraction`).
+
+`document_read_common.py` holds what the reading pair and the error shaping
+share. The capabilities reach the platform only through the typed fred-sdk
+ports — no URL, credential or client lives here.
+
+## Registration
+
+Installing this package *is* the registration: the fred-agents pod
+auto-discovers each capability at boot via the `fred.capabilities` entry
+points declared in `pyproject.toml`. Nothing else to wire.
+
+Authoring guide: `docs/swift/capabilities/AUTHORING.md`.

fred_capability_documents-4.4.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+fred_capability_documents/__init__.py,sha256=udb_Xsa7gosduxzU9BcG3YSYR4u5KWoATb3CQs-lTtA,888
+fred_capability_documents/document_read_common.py,sha256=5fZ-G2RyRCrR47nUTNHiHf7zM55rwobobUQiBXqySqg,10527
+fred_capability_documents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fred_capability_documents/document_extract/__init__.py,sha256=nv_AHyUNjE113JFs_6aB7c1TXSP47fedLBYgW4U7H6Y,1009
+fred_capability_documents/document_extract/capability.py,sha256=VaFHh4cG1n_Cb_KAPVsy3YCl_u9qL3Z4I5jL7sMb2iQ,8582
+fred_capability_documents/document_label_search/__init__.py,sha256=Cc11flcKLFpQ8ql3ledXzstx3DN5T3I_9zp7hbepz5U,1059
+fred_capability_documents/document_label_search/capability.py,sha256=cOy4LIxE_LeAm375MEviHx0LKrVSeEpMMAQnAJJvaF0,10686
+fred_capability_documents/document_similarity/__init__.py,sha256=5rhnxUqtobPeHGWIzdtWBLpoaPfIb7b6xmnnUGDb5uI,1034
+fred_capability_documents/document_similarity/capability.py,sha256=jqXDeKzScDpAHEO77EJG5vIj_6n9kHFPD4AeSRXceBE,11852
+fred_capability_documents/document_summarize/__init__.py,sha256=x1zu5IvC2i6HY_oplpbKXwrSqVPXhbOuiN5T4qFT6-g,1232
+fred_capability_documents/document_summarize/capability.py,sha256=jF19DJrEgZMnqjqr3ruI2mDfBCPoz9JxjanhMuTk9x8,17342
+fred_capability_documents/document_verbatim/__init__.py,sha256=hjC3-1jiX1_RibS_K7uo7qTGfCM8esuWTCUf9qDyS2A,1004
+fred_capability_documents/document_verbatim/capability.py,sha256=UArZNEW9kXrxI8XUQId6vSm_c10CHeHnNxVzRvijkds,5149
+fred_capability_documents-4.4.3.dist-info/METADATA,sha256=xZC2rVLoyL2NJ9bjoLXkMYp7z6CXv2LhIsXMY1nkY00,2530
+fred_capability_documents-4.4.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fred_capability_documents-4.4.3.dist-info/entry_points.txt,sha256=BsOBCx2hpgmrOsuRNlTQ4ZRMOWmLD6AZU-2E3DZIHng,492
+fred_capability_documents-4.4.3.dist-info/top_level.txt,sha256=5pzhsSaq21Qyqzp9Hlv95AjRZvR1_0Pd_OB9UQx71Zw,26
+fred_capability_documents-4.4.3.dist-info/RECORD,,

fred_capability_documents-4.4.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fred_capability_documents-4.4.3.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[fred.capabilities]
+document_extract = fred_capability_documents.document_extract:DocumentExtractCapability
+document_label_search = fred_capability_documents.document_label_search:DocumentLabelSearchCapability
+document_similarity = fred_capability_documents.document_similarity:DocumentSimilarityCapability
+document_summarize = fred_capability_documents.document_summarize:DocumentSummarizeCapability
+document_verbatim = fred_capability_documents.document_verbatim:DocumentVerbatimCapability

fred_capability_documents-4.4.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+fred_capability_documents