zu-huggingface 0.2.2__tar.gz

zu_huggingface-0.2.2/.gitignore

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# uv / venv
+.venv/
+uv.lock.bak
+
+# Test / type caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Zu runtime artifacts
+*.db
+zu.db
+zu.yaml.local
+zu_review.jsonl
+*.review.jsonl
+# Per-agent cost telemetry ledger — machine-local run history, not source.
+cost.jsonl
+# A recorded replay path is learned per-run and machine-local — regenerated on
+# every successful run, not source. The agent ships; its track does not.
+track.json
+# …except the flagship example ships its track on purpose, as a demo of the
+# record/replay convergence (committed; re-runs show as ordinary modifications).
+!examples/agents/vet-appointment/track.json
+
+# Editor / OS
+.idea/
+.vscode/
+.DS_Store
+
+# Claude Code local session state
+.claude/
+
+# Secrets
+.env
+.env.*
+!.env.example
+
+# Microsoft Office temp/lock files
+~$*
+
+# Internal design / strategy docs — kept local, never in the public repo
+*.docx
+*.pdf
+# BUILD.md is the internal build-sequence / deferred-gaps ledger — kept local.
+# (ARCHITECTURE.md is public: an onboarding agent needs the structural map.)
+docs/BUILD.md
+
+# Local secret — API key for live validation, never commit
+zu_demo_key.md
+*_key.md
+
+# Local PyPI publish token — never commit
+/pypi
+
+# Local Discord credentials (bot token / app secrets) — never commit
+/discord

zu_huggingface-0.2.2/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: zu-huggingface
+Version: 0.2.2
+Summary: Zu HuggingFace adapter: task models as typed tools/detectors/validators, behind the supply-chain guards
+Project-URL: Homepage, https://github.com/k3-mt/zu
+Project-URL: Repository, https://github.com/k3-mt/zu
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: zu-core==0.2.1
+Provides-Extra: hosted
+Requires-Dist: huggingface-hub>=0.24; extra == 'hosted'
+Provides-Extra: local
+Requires-Dist: pillow; extra == 'local'
+Requires-Dist: transformers>=4.40; extra == 'local'
+Description-Content-Type: text/markdown
+
+# zu-huggingface
+
+HuggingFace models behind Zu's typed ports. HuggingFace is not a model — it is
+the largest hub of open models across every modality — so "supporting it" means
+three different things, and this package draws the line cleanly
+(Engineering Design §8.3–8.5).
+
+## Chat / vision-language models as the policy — *no code here*
+
+A chat or vision-language model that is the **brain** speaks the OpenAI chat API
+on all three HuggingFace serving surfaces (the router's `/v1`, a dedicated
+Endpoint's `/v1`, or a local vLLM server). So a HuggingFace model as the policy
+is the existing `openai-compatible` provider pointed at a HuggingFace base URL —
+the OpenRouter story exactly, no new adapter:
+
+```yaml
+# agent.yaml — a HuggingFace multimodal model as the policy
+model:    meta-llama/Llama-Vision-...        # any chat / VLM id on the Hub
+provider: openai-compatible
+options:
+  base_url: https://router.huggingface.co/v1  # or an Endpoint, or local vLLM
+  api_key_env: HF_TOKEN
+```
+
+## Task models as tools, detectors, validators — this package
+
+Most HuggingFace models are **not** chat models (OCR, ASR, detection,
+embeddings, classification, …), so they enter through the non-policy ports by
+their **role** (the port is the role, assigned per agent — §4.5):
+
+| Role | Class | Task |
+|------|-------|------|
+| Tool | `Transcribe` (`hf_transcribe`) | speech → text (ASR) |
+| Tool | `ImageToText` (`hf_image_to_text`) | image → text (OCR / caption) |
+| Tool | `DetectObjects` (`hf_detect`) | image → labelled boxes |
+| Tool | `Embed` (`hf_embed`) | text → vector (retrieval / grounding) |
+| Tool | `Classify` (`hf_classify`) | text → labels |
+| Tool | `ZeroShotClassify` (`hf_zero_shot`) | text + labels → scores |
+| Tool | `Summarize` (`hf_summarize`) | text → text |
+| Tool | `Translate` (`hf_translate`) | text → text |
+| Detector | `HfClassifierDetector` | classify an observation → ESCALATE/stop |
+| Validator | `HfClassifierValidator` | classify the result → fail/RETRY |
+
+Each is **parameterised by a model id** (and the role wrappers by the labels
+that matter), so they are wired *by reference in config* per agent rather than
+as zero-config entry points:
+
+```yaml
+tools:
+  - ref: zu_huggingface.tools:Transcribe
+    args: { model: openai/whisper-large-v3 }
+  - ref: zu_huggingface.tools:Embed
+    args: { model: BAAI/bge-large-en-v1.5 }
+detectors:
+  - ref: zu_huggingface.roles:HfClassifierDetector
+    args: { model: facebook/bart-large-mnli, candidate_labels: ["safe","unsafe"], escalate_on: ["unsafe"] }
+```
+
+The typed multimodal `Content` (`Text`/`Image`/`Audio`) from `zu_core.content`
+is the currency in and out — which is what lets a non-chat model slot into the
+loop as cleanly as a chat one.
+
+### Hosted vs local — one seam
+
+Every tool depends only on the `HfClient` seam, so the same tool works:
+
+- **Hosted** — `InferenceClientBackend` wraps `huggingface_hub.InferenceClient`
+  (the serverless router or a dedicated Endpoint). Egresses to
+  `router.huggingface.co`; `HF_TOKEN` is read from the environment inside the
+  backend. `pip install 'zu-huggingface[hosted]'`.
+- **Local** — `PipelineBackend` wraps `transformers.pipeline` for the
+  air-gapped / on-prem case. Reaches no network. Every pipeline is built through
+  the supply-chain guards. `pip install 'zu-huggingface[local]'` (plus a
+  backend such as `torch`).
+
+## The supply chain — safe by default (§8.3)
+
+Pulling a model from the Hub is a supply-chain surface. `supply_chain.py`
+enforces, by default:
+
+- **Pin + hash.** A `ModelPin` should carry a full commit-sha `revision`;
+  `verify_file_hash` checks a downloaded file's sha256.
+- **safetensors, not pickle.** `verify_model_source` rejects `.bin`/`.pt`/`.ckpt`
+  checkpoints (which execute on deserialisation) unless explicitly allowed.
+- **No remote code.** `safe_pipeline_kwargs` forces `trust_remote_code=False`;
+  `assert_no_remote_code` raises if it is relaxed.
+
+The safe configuration is the default — there is nothing to turn *on* to be
+safe, only flags a reviewed case may relax.
+
+## Tests
+
+Offline, no network, no model download: the tools and role wrappers are
+exercised against a fake `HfClient`, and the supply-chain guards are pure.
+`uv run pytest packages/zu-huggingface`.

zu_huggingface-0.2.2/README.md

@@ -0,0 +1,95 @@
+# zu-huggingface
+
+HuggingFace models behind Zu's typed ports. HuggingFace is not a model — it is
+the largest hub of open models across every modality — so "supporting it" means
+three different things, and this package draws the line cleanly
+(Engineering Design §8.3–8.5).
+
+## Chat / vision-language models as the policy — *no code here*
+
+A chat or vision-language model that is the **brain** speaks the OpenAI chat API
+on all three HuggingFace serving surfaces (the router's `/v1`, a dedicated
+Endpoint's `/v1`, or a local vLLM server). So a HuggingFace model as the policy
+is the existing `openai-compatible` provider pointed at a HuggingFace base URL —
+the OpenRouter story exactly, no new adapter:
+
+```yaml
+# agent.yaml — a HuggingFace multimodal model as the policy
+model:    meta-llama/Llama-Vision-...        # any chat / VLM id on the Hub
+provider: openai-compatible
+options:
+  base_url: https://router.huggingface.co/v1  # or an Endpoint, or local vLLM
+  api_key_env: HF_TOKEN
+```
+
+## Task models as tools, detectors, validators — this package
+
+Most HuggingFace models are **not** chat models (OCR, ASR, detection,
+embeddings, classification, …), so they enter through the non-policy ports by
+their **role** (the port is the role, assigned per agent — §4.5):
+
+| Role | Class | Task |
+|------|-------|------|
+| Tool | `Transcribe` (`hf_transcribe`) | speech → text (ASR) |
+| Tool | `ImageToText` (`hf_image_to_text`) | image → text (OCR / caption) |
+| Tool | `DetectObjects` (`hf_detect`) | image → labelled boxes |
+| Tool | `Embed` (`hf_embed`) | text → vector (retrieval / grounding) |
+| Tool | `Classify` (`hf_classify`) | text → labels |
+| Tool | `ZeroShotClassify` (`hf_zero_shot`) | text + labels → scores |
+| Tool | `Summarize` (`hf_summarize`) | text → text |
+| Tool | `Translate` (`hf_translate`) | text → text |
+| Detector | `HfClassifierDetector` | classify an observation → ESCALATE/stop |
+| Validator | `HfClassifierValidator` | classify the result → fail/RETRY |
+
+Each is **parameterised by a model id** (and the role wrappers by the labels
+that matter), so they are wired *by reference in config* per agent rather than
+as zero-config entry points:
+
+```yaml
+tools:
+  - ref: zu_huggingface.tools:Transcribe
+    args: { model: openai/whisper-large-v3 }
+  - ref: zu_huggingface.tools:Embed
+    args: { model: BAAI/bge-large-en-v1.5 }
+detectors:
+  - ref: zu_huggingface.roles:HfClassifierDetector
+    args: { model: facebook/bart-large-mnli, candidate_labels: ["safe","unsafe"], escalate_on: ["unsafe"] }
+```
+
+The typed multimodal `Content` (`Text`/`Image`/`Audio`) from `zu_core.content`
+is the currency in and out — which is what lets a non-chat model slot into the
+loop as cleanly as a chat one.
+
+### Hosted vs local — one seam
+
+Every tool depends only on the `HfClient` seam, so the same tool works:
+
+- **Hosted** — `InferenceClientBackend` wraps `huggingface_hub.InferenceClient`
+  (the serverless router or a dedicated Endpoint). Egresses to
+  `router.huggingface.co`; `HF_TOKEN` is read from the environment inside the
+  backend. `pip install 'zu-huggingface[hosted]'`.
+- **Local** — `PipelineBackend` wraps `transformers.pipeline` for the
+  air-gapped / on-prem case. Reaches no network. Every pipeline is built through
+  the supply-chain guards. `pip install 'zu-huggingface[local]'` (plus a
+  backend such as `torch`).
+
+## The supply chain — safe by default (§8.3)
+
+Pulling a model from the Hub is a supply-chain surface. `supply_chain.py`
+enforces, by default:
+
+- **Pin + hash.** A `ModelPin` should carry a full commit-sha `revision`;
+  `verify_file_hash` checks a downloaded file's sha256.
+- **safetensors, not pickle.** `verify_model_source` rejects `.bin`/`.pt`/`.ckpt`
+  checkpoints (which execute on deserialisation) unless explicitly allowed.
+- **No remote code.** `safe_pipeline_kwargs` forces `trust_remote_code=False`;
+  `assert_no_remote_code` raises if it is relaxed.
+
+The safe configuration is the default — there is nothing to turn *on* to be
+safe, only flags a reviewed case may relax.
+
+## Tests
+
+Offline, no network, no model download: the tools and role wrappers are
+exercised against a fake `HfClient`, and the supply-chain guards are pure.
+`uv run pytest packages/zu-huggingface`.

zu_huggingface-0.2.2/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "zu-huggingface"
+version = "0.2.2"
+description = "Zu HuggingFace adapter: task models as typed tools/detectors/validators, behind the supply-chain guards"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Typing :: Typed",
+]
+# The core + the multimodal Content currency are all that is always needed; the
+# heavy SDKs are optional extras, imported lazily, so the tools are testable
+# offline against a fake client and a base install costs nothing.
+dependencies = ["zu-core==0.2.1"]
+
+[project.optional-dependencies]
+hosted = ["huggingface_hub>=0.24"]   # the Inference Providers router / Endpoints
+local = ["transformers>=4.40", "pillow"]  # local pipelines (also needs a backend, e.g. torch)
+
+# The task-model tools and the classifier detector/validator are PARAMETERISED
+# (a model id, and for the role wrappers the labels that matter), so they are
+# wired by reference in config per agent rather than as zero-config entry points
+# — see the README. The package's contract is its importable classes + the
+# HfClient seam + the supply-chain guards.
+
+[project.urls]
+Homepage = "https://github.com/k3-mt/zu"
+Repository = "https://github.com/k3-mt/zu"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/zu_huggingface"]

zu_huggingface-0.2.2/src/zu_huggingface/__init__.py

@@ -0,0 +1,74 @@
+"""zu-huggingface — HuggingFace models behind Zu's typed ports (§8.3–8.5).
+
+HuggingFace is not a model — it is the largest hub of open models across every
+modality. This package reaches it three ways, all behind configuration:
+
+* **Chat / vision-language models as the policy** need *no code here* — they
+  speak the OpenAI chat API on all three serving surfaces (the router's ``/v1``,
+  an Endpoint's ``/v1``, or a local vLLM), so a HuggingFace model as the brain
+  is the existing ``openai-compatible`` provider pointed at a HuggingFace base
+  URL (see this package's README). It is the OpenRouter story exactly.
+
+* **Task models** (ASR, OCR, detection, embeddings, classification,
+  summarisation, translation) are *not* chat models — each has its own typed
+  I/O — so they enter through the non-policy ports by their role: as **Tools**
+  (``tools.py``) and as **detectors / validators** (``roles.py``), over the one
+  :class:`HfClient` seam (``client.py``) that works hosted or local.
+
+* **The supply chain** (``supply_chain.py``) makes pulling any of them safe by
+  default: pin + hash, safetensors not pickle, never trust remote code.
+"""
+
+from __future__ import annotations
+
+from .client import HF_ROUTER, HfClient, InferenceClientBackend, PipelineBackend
+from .roles import HfClassifierDetector, HfClassifierValidator
+from .supply_chain import (
+    ModelPin,
+    SupplyChainError,
+    SupplyChainPolicy,
+    assert_no_remote_code,
+    file_sha256,
+    safe_pipeline_kwargs,
+    verify_file_hash,
+    verify_model_source,
+)
+from .tools import (
+    Classify,
+    DetectObjects,
+    Embed,
+    ImageToText,
+    Summarize,
+    Transcribe,
+    Translate,
+    ZeroShotClassify,
+)
+
+__all__ = [
+    # client seam
+    "HfClient",
+    "HF_ROUTER",
+    "InferenceClientBackend",
+    "PipelineBackend",
+    # tools
+    "Transcribe",
+    "ImageToText",
+    "DetectObjects",
+    "Embed",
+    "Classify",
+    "ZeroShotClassify",
+    "Summarize",
+    "Translate",
+    # role wrappers
+    "HfClassifierDetector",
+    "HfClassifierValidator",
+    # supply chain
+    "ModelPin",
+    "SupplyChainPolicy",
+    "SupplyChainError",
+    "verify_model_source",
+    "assert_no_remote_code",
+    "safe_pipeline_kwargs",
+    "file_sha256",
+    "verify_file_hash",
+]

zu_huggingface-0.2.2/src/zu_huggingface/client.py

@@ -0,0 +1,187 @@
+"""The HuggingFace client seam — one task-method interface, three serving surfaces.
+
+Most HuggingFace models are *not* chat models: OCR, speech recognition, object
+detection, and embedding models each have their own typed input/output, so they
+enter Zu through the non-policy ports by their role (§8.5). This module is the
+thin seam the HuggingFace *tools* call, so the same tool works whether the model
+is served hosted (the Inference Providers router) or local (a transformers
+pipeline) — the integration is done once, here.
+
+``HfClient`` is the protocol the tools depend on. Two adapters implement it:
+
+* :class:`InferenceClientBackend` — wraps ``huggingface_hub.InferenceClient``
+  (hosted; the router or a dedicated Endpoint), egressing to the HF router.
+* :class:`PipelineBackend` — wraps ``transformers.pipeline`` (local; the
+  air-gapped / on-prem case), constructed only through the supply-chain guards
+  (§8.3): a pinned revision and ``trust_remote_code=False``.
+
+Both heavy SDKs are imported lazily, so installing ``zu-huggingface`` without
+the extras costs nothing and the tools are testable offline against a fake
+client. Credentials (``HF_TOKEN``) are resolved from the environment *inside*
+the backend, never placed in the model's context.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Protocol, runtime_checkable
+
+from .supply_chain import ModelPin, SupplyChainPolicy, safe_pipeline_kwargs
+
+# The Inference Providers router — the hosted default, OpenAI-compatible for
+# chat at /v1 but task-native through the InferenceClient methods.
+HF_ROUTER = "router.huggingface.co"
+
+
+@runtime_checkable
+class HfClient(Protocol):
+    """The task methods the HuggingFace tools call. Inputs/outputs are plain
+    Python (bytes for media, str for text, list[dict] for structured) so the
+    tools own the translation to/from typed :class:`zu_core.content` Content."""
+
+    def transcribe(self, audio: bytes, model: str) -> str: ...
+    def image_to_text(self, image: bytes, model: str) -> str: ...
+    def object_detection(self, image: bytes, model: str) -> list[dict]: ...
+    def text_classification(self, text: str, model: str) -> list[dict]: ...
+    def zero_shot(self, text: str, labels: list[str], model: str) -> list[dict]: ...
+    def embed(self, text: str, model: str) -> list[float]: ...
+    def summarize(self, text: str, model: str) -> str: ...
+    def translate(self, text: str, model: str) -> str: ...
+
+
+def _scores(raw: Any) -> list[dict]:
+    """Normalise a classifier response to ``[{"label","score"}, …]`` sorted by
+    score desc — the shape every classification tool/detector reads."""
+    out: list[dict] = []
+    if isinstance(raw, dict) and "labels" in raw and "scores" in raw:  # zero-shot shape
+        out = [{"label": str(lbl), "score": float(sc)}
+               for lbl, sc in zip(raw["labels"], raw["scores"], strict=False)]
+    elif isinstance(raw, list):
+        for item in raw:
+            if isinstance(item, dict) and "label" in item:
+                out.append({"label": str(item["label"]), "score": float(item.get("score", 0.0))})
+    return sorted(out, key=lambda d: d["score"], reverse=True)
+
+
+class InferenceClientBackend:
+    """Hosted HuggingFace via ``huggingface_hub.InferenceClient`` (lazy import).
+
+    The same model id works through the serverless router or a dedicated
+    Endpoint; ``HF_TOKEN`` is read from the environment here.
+    """
+
+    egress_host = HF_ROUTER
+
+    def __init__(
+        self,
+        *,
+        provider: str = "hf-inference",
+        token_env: str = "HF_TOKEN",
+        client: Any = None,
+    ) -> None:
+        self._provider = provider
+        self._token_env = token_env
+        self._client = client  # injectable for tests
+
+    def _c(self) -> Any:
+        if self._client is None:
+            try:
+                from huggingface_hub import InferenceClient
+            except ImportError as e:  # pragma: no cover - exercised only without the extra
+                raise RuntimeError(
+                    "the hosted HuggingFace backend needs `huggingface_hub` "
+                    "(install zu-huggingface[hosted])"
+                ) from e
+            self._client = InferenceClient(provider=self._provider, api_key=os.environ.get(self._token_env))
+        return self._client
+
+    def transcribe(self, audio: bytes, model: str) -> str:
+        r = self._c().automatic_speech_recognition(audio, model=model)
+        return r if isinstance(r, str) else str(getattr(r, "text", r))
+
+    def image_to_text(self, image: bytes, model: str) -> str:
+        r = self._c().image_to_text(image, model=model)
+        return r if isinstance(r, str) else str(getattr(r, "generated_text", r))
+
+    def object_detection(self, image: bytes, model: str) -> list[dict]:
+        r = self._c().object_detection(image, model=model)
+        return [dict(item) for item in r]
+
+    def text_classification(self, text: str, model: str) -> list[dict]:
+        return _scores(self._c().text_classification(text, model=model))
+
+    def zero_shot(self, text: str, labels: list[str], model: str) -> list[dict]:
+        return _scores(self._c().zero_shot_classification(text, candidate_labels=labels, model=model))
+
+    def embed(self, text: str, model: str) -> list[float]:
+        r = self._c().feature_extraction(text, model=model)
+        return [float(x) for x in (r.tolist() if hasattr(r, "tolist") else r)]
+
+    def summarize(self, text: str, model: str) -> str:
+        r = self._c().summarization(text, model=model)
+        return r if isinstance(r, str) else str(getattr(r, "summary_text", r))
+
+    def translate(self, text: str, model: str) -> str:
+        r = self._c().translation(text, model=model)
+        return r if isinstance(r, str) else str(getattr(r, "translation_text", r))
+
+
+class PipelineBackend:
+    """Local HuggingFace via ``transformers.pipeline`` (lazy import).
+
+    The only option for air-gapped / on-prem. Every pipeline is built through
+    :func:`safe_pipeline_kwargs` — a pinned revision and ``trust_remote_code``
+    forced off — so the §8.3 supply-chain rules hold by construction. Pipelines
+    are cached per (task, model).
+    """
+
+    egress_host = ""  # local — no egress
+
+    def __init__(self, policy: SupplyChainPolicy | None = None) -> None:
+        self._policy = policy or SupplyChainPolicy()
+        self._cache: dict[tuple[str, str], Any] = {}
+
+    def _pipe(self, task: str, model: str) -> Any:
+        key = (task, model)
+        if key not in self._cache:
+            try:
+                from transformers import pipeline
+            except ImportError as e:  # pragma: no cover - exercised only without the extra
+                raise RuntimeError(
+                    "the local HuggingFace backend needs `transformers` "
+                    "(install zu-huggingface[local])"
+                ) from e
+            kwargs = safe_pipeline_kwargs(ModelPin(repo_id=model), self._policy)
+            self._cache[key] = pipeline(task, **kwargs)
+        return self._cache[key]
+
+    def transcribe(self, audio: bytes, model: str) -> str:
+        return str(self._pipe("automatic-speech-recognition", model)(audio)["text"])
+
+    def image_to_text(self, image: bytes, model: str) -> str:
+        r = self._pipe("image-to-text", model)(image)
+        return str(r[0]["generated_text"] if isinstance(r, list) else r["generated_text"])
+
+    def object_detection(self, image: bytes, model: str) -> list[dict]:
+        return [dict(item) for item in self._pipe("object-detection", model)(image)]
+
+    def text_classification(self, text: str, model: str) -> list[dict]:
+        return _scores(self._pipe("text-classification", model)(text))
+
+    def zero_shot(self, text: str, labels: list[str], model: str) -> list[dict]:
+        return _scores(self._pipe("zero-shot-classification", model)(text, candidate_labels=labels))
+
+    def embed(self, text: str, model: str) -> list[float]:
+        r = self._pipe("feature-extraction", model)(text)
+        # pipelines return [[token-vectors]]; mean-pool to one vector
+        vecs = r[0] if isinstance(r, list) else r
+        if vecs and isinstance(vecs[0], list):
+            cols = list(zip(*vecs, strict=False))
+            return [sum(c) / len(c) for c in cols]
+        return [float(x) for x in vecs]
+
+    def summarize(self, text: str, model: str) -> str:
+        return str(self._pipe("summarization", model)(text)[0]["summary_text"])
+
+    def translate(self, text: str, model: str) -> str:
+        return str(self._pipe("translation", model)(text)[0]["translation_text"])