labs-agent-lib 0.1.0__py3-none-any.whl

labs_agent_lib/__init__.py

@@ -0,0 +1,16 @@
+from .logger import get_logger
+from .agent_settings import get_agent_settings
+from .file_reader.extractor import extract_text
+from .file_writer import file_writer
+from .agent_environment import get_agent_environment
+from .observability import AgentTranscriptWriter, PromptLogWriter
+
+__all__ = [
+    "get_logger",
+    "get_agent_settings",
+    "extract_text",
+    "file_writer",
+    "get_agent_environment",
+    "AgentTranscriptWriter",
+    "PromptLogWriter",
+]

labs_agent_lib/agent_environment/__init__.py

@@ -0,0 +1,12 @@
+from labs_agent_lib.agent_settings import AgentSettings, LogLevel, Provider, get_agent_settings
+
+from .agent_environment import AgentEnvironment, get_agent_environment
+
+__all__ = [
+    "AgentEnvironment",
+    "AgentSettings",
+    "LogLevel",
+    "Provider",
+    "get_agent_environment",
+    "get_agent_settings",
+]

labs_agent_lib/agent_environment/agent_environment.py

@@ -0,0 +1,55 @@
+"""Builds the Claude Agent SDK environment for the gateway configured in AgentSettings."""
+
+from dataclasses import dataclass
+
+from labs_agent_lib.agent_settings import AgentSettings, Provider
+
+
+@dataclass(frozen=True, slots=True)
+class AgentEnvironment:
+    """What ClaudeAgentOptions needs to reach a model gateway.
+
+    Attributes:
+        env: Environment overrides for ClaudeAgentOptions.env; the SDK merges this
+            over the inherited environment before spawning the `claude` subprocess.
+            The model itself is set in code, not here.
+    """
+
+    env: dict[str, str]
+
+
+def get_agent_environment(settings: AgentSettings) -> AgentEnvironment:
+    """Build the AgentEnvironment for the provider configured in settings.provider.
+
+    Both supported providers speak the Anthropic Messages API, so routing to either
+    one is just a matter of pointing ANTHROPIC_BASE_URL/ANTHROPIC_API_KEY at it.
+    """
+    if settings.provider is Provider.PORTKEY:
+        base_url, api_key = settings.portkey_base_url, settings.portkey_api_key
+    else:
+        base_url, api_key = settings.anthropic_base_url, settings.anthropic_api_key
+
+    if not api_key.get_secret_value():
+        raise ValueError(
+            f"LABS_AGENT_LIB_{settings.provider.value.upper()}_API_KEY is required when provider={settings.provider}"
+        )
+
+    if settings.provider is Provider.PORTKEY:
+        headers = f"x-portkey-api-key: {api_key.get_secret_value()}"
+        if settings.portkey_virtual:
+            headers += f"\nx-portkey-virtual-key: {settings.portkey_virtual}"
+        env = {
+            "ANTHROPIC_BASE_URL": base_url,
+            "ANTHROPIC_API_KEY": api_key.get_secret_value(),
+            "ANTHROPIC_CUSTOM_HEADERS": headers,
+        }
+    else:
+        env = {
+            "ANTHROPIC_BASE_URL": base_url,
+            "ANTHROPIC_API_KEY": api_key.get_secret_value(),
+        }
+
+    if settings.disable_prompt_caching:
+        env["DISABLE_PROMPT_CACHING"] = "1"
+
+    return AgentEnvironment(env=env)

labs_agent_lib/agent_settings.py

@@ -0,0 +1,62 @@
+"""Application settings for projects built on labs-agent-lib.
+
+Consuming projects configure this via a `.env` file (or real env vars) at their own
+repository root, prefixing every key with `LABS_AGENT_LIB_`, e.g.:
+
+    LABS_AGENT_LIB_PROVIDER=anthropic
+    LABS_AGENT_LIB_LOG_LEVEL=DEBUG
+    LABS_AGENT_LIB_ANTHROPIC_API_KEY=sk-ant-...
+
+Call `get_agent_settings()` to get the cached singleton instead of instantiating
+`AgentSettings` directly, so the `.env` file is only read once per process.
+"""
+
+from enum import StrEnum
+from functools import lru_cache
+
+from pydantic import SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Provider(StrEnum):
+    """Anthropic-Messages-API-compatible gateways this agent can route through."""
+
+    PORTKEY = "portkey"
+    ANTHROPIC = "anthropic"
+
+
+class LogLevel(StrEnum):
+    """Verbosity for labs_resume_agent.libs.logger - maps 1:1 to stdlib logging levels."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+
+
+class AgentSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_prefix="LABS_AGENT_LIB_",
+        env_file_encoding="utf-8",
+        extra="ignore",
+        populate_by_name=True,
+    )
+
+    provider: Provider = Provider.PORTKEY
+    log_level: LogLevel = LogLevel.INFO
+
+    portkey_base_url: str = "https://portkeygateway.perficient.com"
+    portkey_api_key: SecretStr = SecretStr("")
+    portkey_virtual: str = ""
+    
+    anthropic_base_url: str = "https://api.anthropic.com"
+    anthropic_api_key: SecretStr = SecretStr("")
+
+    disable_prompt_caching: bool = False
+
+
+@lru_cache
+def get_agent_settings() -> AgentSettings:
+    """Return the cached application settings singleton."""
+    return AgentSettings()

labs_agent_lib/file_reader/__init__.py

@@ -0,0 +1,8 @@
+from .errors import UnsupportedFileTypeError
+from .extractor import SUPPORTED_EXTENSIONS, extract_text
+
+__all__ = [
+    "SUPPORTED_EXTENSIONS",
+    "UnsupportedFileTypeError",
+    "extract_text",
+]

labs_agent_lib/file_reader/docx_reader.py

@@ -0,0 +1,9 @@
+"""Extracts text from Word (.docx) files."""
+
+import docx2txt
+from pathlib import Path
+
+def read_docx(path: Path) -> str:
+    """Extrae todo el texto de un DOCX, incluyendo tablas."""
+    text = docx2txt.process(path)
+    return text.strip()

labs_agent_lib/file_reader/errors.py

@@ -0,0 +1,13 @@
+"""Errors raised by the file_reader library."""
+
+
+class UnsupportedFileTypeError(ValueError):
+    """Raised when a file's extension has no registered reader."""
+
+    def __init__(self, extension: str, supported: list[str]) -> None:
+        self.extension = extension
+        self.supported = supported
+        super().__init__(
+            f"Unsupported file type '{extension or '(none)'}'. "
+            f"Supported extensions: {', '.join(supported)}"
+        )

labs_agent_lib/file_reader/extractor.py

@@ -0,0 +1,35 @@
+"""Picks a reader for a document from its extension and extracts its text."""
+
+from pathlib import Path
+
+from .docx_reader import read_docx
+from .errors import UnsupportedFileTypeError
+from .pdf_reader import read_pdf
+from .text_reader import read_text_file
+
+_READERS = {
+    ".pdf": read_pdf,
+    ".docx": read_docx,
+    ".txt": read_text_file,
+    ".md": read_text_file,
+    ".markdown": read_text_file,
+}
+
+SUPPORTED_EXTENSIONS = sorted(_READERS)
+
+
+def extract_text(file_path: str) -> str:
+    """Read `file_path` and return its text content.
+
+    The reader is picked from the file's extension (see SUPPORTED_EXTENSIONS);
+    callers don't need to know which parser handles which format.
+    """
+    path = Path(file_path)
+    if not path.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    read = _READERS.get(path.suffix.lower())
+    if read is None:
+        raise UnsupportedFileTypeError(path.suffix, SUPPORTED_EXTENSIONS)
+
+    return read(path)

labs_agent_lib/file_reader/pdf_reader.py

@@ -0,0 +1,11 @@
+"""Extracts text from PDF files."""
+
+
+import pymupdf
+from pathlib import Path
+
+def read_pdf(path: Path) -> str:
+    """Return the concatenated text of every page in a PDF file."""
+    doc = pymupdf.open(path)
+    pages = [page.get_text("text") for page in doc]
+    return "\n\n".join(pages).strip()

labs_agent_lib/file_reader/text_reader.py

@@ -0,0 +1,7 @@
+"""Extracts text from plain-text files (.txt, .md, and similar)."""
+
+from pathlib import Path
+
+def read_text_file(path: Path) -> str:
+    """Return the file's contents decoded as UTF-8."""
+    return path.read_text(encoding="utf-8", errors="replace").strip()

labs_agent_lib/file_writer/__init__.py

@@ -0,0 +1,7 @@
+"""Utilities for writing/moving resume files on disk."""
+
+from .resume_mover import file_writer
+
+__all__ = [
+    "file_writer",
+]

labs_agent_lib/file_writer/resume_mover.py

@@ -0,0 +1,13 @@
+"""Moves resume files into their target folder."""
+
+import shutil
+from pathlib import Path
+
+
+def file_writer(source_file_path: str, target_path: str) -> None:
+    """Moves `source_file_path` into `target_path`, creating the folder if needed."""
+    source = Path(source_file_path)
+    target_dir = Path(target_path)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    shutil.move(source_file_path, target_dir / source.name)

labs_agent_lib/logger.py

@@ -0,0 +1,37 @@
+"""Centralized logging setup for the whole app (coordinators, subagent task events, MCP tools).
+
+Usage: `logger = get_logger(__name__)` at module level, then `logger.debug/info/warning/error(...)`.
+Verbosity is controlled by AgentSettings.log_level (LABS_RESUME_AGENT_LOG_LEVEL) - set it to DEBUG to
+see every step (tool calls, per-task progress) or leave it at INFO to only see the high-level
+phases (task started/done, final results). Logs go to stderr, not stdout: mcp_server.py runs as
+an MCP stdio subprocess, and anything printed to stdout there would corrupt the MCP protocol.
+"""
+
+import logging
+import sys
+
+from labs_agent_lib.agent_settings import get_agent_settings
+
+_configured_roots: set[str] = set()
+
+
+def _configure(root_name: str) -> None:
+    if root_name in _configured_roots:
+        return
+    root = logging.getLogger(root_name)
+    root.setLevel(get_agent_settings().log_level.value)
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(name)s: %(message)s"))
+    root.addHandler(handler)
+    root.propagate = False
+    _configured_roots.add(root_name)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a logger in the caller's package hierarchy; pass __name__ from the call site.
+
+    The top-level package segment of `name` is configured as its own logging root on first
+    use, so each consuming project gets its level/handler without hardcoding its package name.
+    """
+    _configure(name.split(".", 1)[0])
+    return logging.getLogger(name)

labs_agent_lib/observability/__init__.py

@@ -0,0 +1,11 @@
+"""Shared prompt-log / agent-transcript JSONL writers for Claude-agent-based projects.
+
+Each consuming project supplies its own settings object (just needs
+`observability_enabled`, `prompt_log_dir`, `agent_transcript_dir`) and a `service` name;
+see `PromptLogWriter`/`AgentTranscriptWriter` for the full contract.
+"""
+
+from .agent_transcript import AgentTranscriptWriter
+from .prompt_log import PromptLogWriter
+
+__all__ = ["AgentTranscriptWriter", "PromptLogWriter"]

labs_agent_lib/observability/_jsonl_writer.py

@@ -0,0 +1,31 @@
+"""Shared JSONL append helper backing the prompt log and agent transcript writers."""
+
+from datetime import UTC, datetime
+import json
+from pathlib import Path
+from typing import Any
+
+
+def append_jsonl(directory: str, file_stem: str, record: dict[str, Any]) -> None:
+    """Appends one JSON line to `{directory}/{file_stem}.jsonl`, creating the directory if needed."""
+    path = Path(directory)
+    path.mkdir(parents=True, exist_ok=True)
+    line = json.dumps(record, ensure_ascii=False, default=str)
+    with (path / f"{file_stem}.jsonl").open("a", encoding="utf-8") as handle:
+        handle.write(line + "\n")
+
+
+def utc_now_iso() -> str:
+    """Returns the current UTC time as an ISO-8601 string."""
+    return datetime.now(UTC).isoformat()
+
+
+def file_stem_for(correlation_id: str, agent: str | None = None) -> str:
+    """Builds the JSONL file stem for one `correlation_id`, optionally keyed by agent too.
+
+    Pass `agent` when several agents can write concurrently under the same
+    `correlation_id` (e.g. parallel sub-agent tool calls fanned out by a coordinator in
+    one turn), so each gets its own file instead of interleaving writes into a shared one.
+    """
+    base = correlation_id or "no-correlation-id"
+    return f"{base}__{agent}" if agent else base

labs_agent_lib/observability/agent_transcript.py

@@ -0,0 +1,159 @@
+"""Agent transcript: the full, ordered play-by-play of one agent session or tool call.
+
+Complements the prompt log (a flat index of what was asked). See a consuming project's
+`documentation/prompt_log_and_agent_transcript.md` for the full design and how
+`correlation_id` ties multiple services together.
+"""
+
+from typing import Any
+
+from ._jsonl_writer import append_jsonl, file_stem_for, utc_now_iso
+
+
+class AgentTranscriptWriter:
+    """Appends one event line per step of an agent run to `{agent_transcript_dir}/{file_stem}.jsonl`.
+
+    `settings` only needs `observability_enabled: bool` and `agent_transcript_dir: str`
+    attributes - any project's own settings object works, no shared schema required.
+    `service` names the calling project in every record (e.g. `"mcp_skills_extractor_agents"`).
+    Pass `key_by_agent=True` when multiple agents can write under the same
+    `correlation_id` concurrently, so each gets its own file instead of interleaving
+    writes - e.g. several extraction sub-agents fanned out in parallel by a coordinator.
+
+    Methods cover the union of events either a coordinator (`session_start`,
+    `assistant_text`, `tool_use`, `tool_result`, `session_end`) or a self-correcting
+    sub-agent (`session_start`, `assistant_text`, `retry`, `session_end`) needs. Callers
+    only use the subset that applies to them.
+    """
+
+    def __init__(self, settings: Any, *, service: str, key_by_agent: bool = False) -> None:
+        self.settings = settings
+        self.service = service
+        self.key_by_agent = key_by_agent
+
+    def _write(
+        self,
+        correlation_id: str,
+        agent: str,
+        event: str,
+        *,
+        session_id: str | None = None,
+        **fields: Any,
+    ) -> None:
+        if not self.settings.observability_enabled:
+            return
+
+        record: dict[str, Any] = {
+            "timestamp": utc_now_iso(),
+            "correlation_id": correlation_id,
+            "service": self.service,
+            "agent": agent,
+            "session_id": session_id,
+            "event": event,
+            **fields,
+        }
+        file_stem = file_stem_for(correlation_id, agent if self.key_by_agent else None)
+        append_jsonl(self.settings.agent_transcript_dir, file_stem, record)
+
+    def session_start(
+        self,
+        correlation_id: str,
+        agent: str,
+        *,
+        model: str,
+        system_prompt: str,
+        user_prompt: str,
+        allowed_tools: list[str] | None = None,
+    ) -> None:
+        """Records the opening of a session/first attempt, including the system prompt once."""
+        self._write(
+            correlation_id,
+            agent,
+            "session_start",
+            model=model,
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            allowed_tools=list(allowed_tools) if allowed_tools is not None else None,
+        )
+
+    def assistant_text(
+        self,
+        correlation_id: str,
+        agent: str,
+        *,
+        text: str,
+        session_id: str | None = None,
+    ) -> None:
+        """Records a text block/raw response the agent emitted."""
+        self._write(correlation_id, agent, "assistant_text", text=text, session_id=session_id)
+
+    def tool_use(
+        self,
+        correlation_id: str,
+        agent: str,
+        *,
+        tool_use_id: str,
+        tool_name: str,
+        target_field: str,
+        tool_input: Any,
+    ) -> None:
+        """Records a tool call the agent dispatched."""
+        self._write(
+            correlation_id,
+            agent,
+            "tool_use",
+            tool_use_id=tool_use_id,
+            tool_name=tool_name,
+            target_field=target_field,
+            tool_input=tool_input,
+        )
+
+    def tool_result(
+        self,
+        correlation_id: str,
+        agent: str,
+        *,
+        tool_use_id: str,
+        tool_name: str,
+        target_field: str,
+        is_error: bool,
+        output: str,
+    ) -> None:
+        """Records the result that came back for a previously dispatched tool call."""
+        self._write(
+            correlation_id,
+            agent,
+            "tool_result",
+            tool_use_id=tool_use_id,
+            tool_name=tool_name,
+            target_field=target_field,
+            is_error=is_error,
+            output=output,
+        )
+
+    def retry(self, correlation_id: str, agent: str, *, attempt: int, attempts: int, error: str) -> None:
+        """Records a self-correction turn triggered by a schema/validation failure."""
+        self._write(correlation_id, agent, "retry", attempt=attempt, attempts=attempts, error=error)
+
+    def session_end(
+        self,
+        correlation_id: str,
+        agent: str,
+        *,
+        is_error: bool,
+        session_id: str | None = None,
+        stop_reason: str | None = None,
+        result: Any = None,
+        error: str | None = None,
+    ) -> None:
+        """Records the final outcome of the session/tool call."""
+        self._write(
+            correlation_id,
+            agent,
+            "session_end",
+            session_id=session_id,
+            stop_reason=stop_reason,
+            is_error=is_error,
+            result=result,
+            error=error,
+        )

labs_agent_lib/observability/prompt_log.py

@@ -0,0 +1,55 @@
+"""Prompt log: one audit line per outbound LLM request attempt - "what we asked the model".
+
+Complements the agent transcript (the full play-by-play of a session). The prompt log is
+a flat, append-only index meant for quick search/filtering across runs; see a consuming
+project's `documentation/prompt_log_and_agent_transcript.md` for the full design and how
+`correlation_id` ties multiple services together.
+"""
+
+from typing import Any
+
+from ._jsonl_writer import append_jsonl, file_stem_for, utc_now_iso
+
+
+class PromptLogWriter:
+    """Appends one line per LLM call attempt to `{prompt_log_dir}/{file_stem}.jsonl`.
+
+    `settings` only needs `observability_enabled: bool` and `prompt_log_dir: str`
+    attributes - any project's own settings object works, no shared schema required.
+    `service` names the calling project in every record (e.g. `"talent_distiller_agent"`).
+    Pass `key_by_agent=True` when multiple agents can log under the same `correlation_id`
+    concurrently, so each gets its own file instead of interleaving writes.
+    """
+
+    def __init__(self, settings: Any, *, service: str, key_by_agent: bool = False) -> None:
+        self.settings = settings
+        self.service = service
+        self.key_by_agent = key_by_agent
+
+    def log_prompt(
+        self,
+        *,
+        correlation_id: str,
+        agent: str,
+        model: str,
+        system_prompt_name: str,
+        user_prompt: str,
+        attempt: int = 1,
+    ) -> None:
+        """Records one outbound prompt. No-ops when `settings.observability_enabled` is `False`."""
+        if not self.settings.observability_enabled:
+            return
+
+        record: dict[str, Any] = {
+            "timestamp": utc_now_iso(),
+            "correlation_id": correlation_id,
+            "service": self.service,
+            "agent": agent,
+            "event": "prompt",
+            "model": model,
+            "system_prompt_name": system_prompt_name,
+            "user_prompt": user_prompt,
+            "attempt": attempt,
+        }
+        file_stem = file_stem_for(correlation_id, agent if self.key_by_agent else None)
+        append_jsonl(self.settings.prompt_log_dir, file_stem, record)

labs_agent_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: labs-agent-lib
+Version: 0.1.0
+Summary: Shared utilities (settings, logging, document text extraction, Claude Agent SDK environment) for Claude-agent-based projects.
+Author: Luis Alberto Bolaños Salazar
+Author-email: Luis Alberto Bolaños Salazar <68343185+albertbolanoss@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: docx2txt>=0.9
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: pydantic-settings>=2.16.1
+Requires-Dist: pymupdf>=2.0
+Requires-Dist: python-dotenv>=1.2.4
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# labs-agent-lib
+
+Shared utilities extracted from [`candidate-match-agent`](https://github.com/albertbolanoss/candidate-match-agent) for
+building Claude-agent-based projects:
+
+- `labs_agent_lib.agent_settings` — a `pydantic-settings` `AgentSettings` model (gateway provider, log level, Portkey/Anthropic
+  credentials, prompt-caching toggle).
+- `labs_agent_lib.logger` — centralized stderr logging, configured from `AgentSettings.log_level`.
+- `labs_agent_lib.file_reader` — extracts plain text from `.pdf`, `.docx`, `.txt`, `.md`, and `.markdown` files.
+- `labs_agent_lib.agent_environment` — builds the `ClaudeAgentOptions.env` dict (base URL, API key, custom headers)
+  for the configured provider.
+- `labs_agent_lib.observability` — `PromptLogWriter`/`AgentTranscriptWriter`: JSONL writers for a prompt log
+  ("what we asked the model") and an agent transcript ("what happened, step by step"), correlated by a
+  caller-supplied `correlation_id`. Each consuming project supplies its own settings object (just needs
+  `observability_enabled`, `prompt_log_dir`, `agent_transcript_dir`) and a `service` name.
+
+## Install
+
+```bash
+uv add labs-agent-lib
+# or
+pip install labs-agent-lib
+```
+
+## Configuration
+
+`AgentSettings` reads from your project's own `.env` file (or real environment variables), with every key
+prefixed `LABS_AGENT_LIB_`:
+
+| Env var | Default | Description |
+| --- | --- | --- |
+| `LABS_AGENT_LIB_PROVIDER` | `portkey` | Gateway to route through: `portkey` or `anthropic`. |
+| `LABS_AGENT_LIB_LOG_LEVEL` | `INFO` | `DEBUG`, `INFO`, `WARNING`, or `ERROR`. |
+| `LABS_AGENT_LIB_PORTKEY_BASE_URL` | `https://portkeygateway.perficient.com` | Portkey gateway base URL. |
+| `LABS_AGENT_LIB_PORTKEY_API_KEY` | `""` | Portkey API key (secret). |
+| `LABS_AGENT_LIB_PORTKEY_VIRTUAL` | `""` | Provider/credential alias from the Portkey dashboard (e.g. `aws-bedrock-use2`). |
+| `LABS_AGENT_LIB_ANTHROPIC_BASE_URL` | `https://api.anthropic.com` | Anthropic API base URL. |
+| `LABS_AGENT_LIB_ANTHROPIC_API_KEY` | `""` | Anthropic API key (secret). |
+| `LABS_AGENT_LIB_DISABLE_PROMPT_CACHING` | `false` | Disable Anthropic prompt caching, e.g. while iterating on a system prompt. |
+
+Example `.env`:
+
+```dotenv
+LABS_AGENT_LIB_PROVIDER=anthropic
+LABS_AGENT_LIB_ANTHROPIC_API_KEY=sk-ant-...
+```
+
+## Usage
+
+```python
+from labs_agent_lib import get_logger, get_agent_settings, get_agent_environment
+from labs_agent_lib.file_reader import extract_text
+
+logger = get_logger(__name__)
+settings = get_agent_settings()
+env = get_agent_environment(settings)
+text = extract_text("resume.pdf")
+```
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+```

labs_agent_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+labs_agent_lib/__init__.py,sha256=itGrZzRqTvUlxwEkddnJVBs-NNfB6dc0n2pV2HNZQxM,475
+labs_agent_lib/agent_environment/__init__.py,sha256=RqUGGPuQemne07DTBONw8_rKkJ4bK42_JiYa6l6OMK4,327
+labs_agent_lib/agent_environment/agent_environment.py,sha256=FUJLmoTUQKqNEAcozQlwm4rwWI_gh5M8BlJrCdgcfkI,2066
+labs_agent_lib/agent_settings.py,sha256=KqWHUhgAfwNIB1TBAH1yPriGFUBHS7MWKC_mUQRjUPA,1838
+labs_agent_lib/file_reader/__init__.py,sha256=o1Hvsys1Ex74IRKGJ6e6T8MQHQflyhwuGHMtl1DwxGg,198
+labs_agent_lib/file_reader/docx_reader.py,sha256=XiUjfadt7Z4wbfWJjVtLlV8_SMmJg8v8-ZkxmRa5PuA,251
+labs_agent_lib/file_reader/errors.py,sha256=iHtLVT2Tu2yr0FV3cY4MAFkJvKVSQvUhodRDDu3XgzM,463
+labs_agent_lib/file_reader/extractor.py,sha256=_4aUf_TDdSZik_n-cxsGFku9qT0mnWknOLkSo3coC3A,1011
+labs_agent_lib/file_reader/pdf_reader.py,sha256=vOLRGO3AxY_2-wtNPFJbB1O5diTeuGCfSKGNjZzAr_I,308
+labs_agent_lib/file_reader/text_reader.py,sha256=rQJSLG8DEH3vp-9oBSqMfXXqDFJoe0ZIo8sRzY9QIGA,266
+labs_agent_lib/file_writer/__init__.py,sha256=d_Rcex8-RuJWAuHNV2qf1tVzGOGLoU31srhodlDChRE,137
+labs_agent_lib/file_writer/resume_mover.py,sha256=DnUv0ZySzPjIuCVD_GDHDWM63w35afw90l4nNhIPAZs,440
+labs_agent_lib/logger.py,sha256=NQW791rUg5_4p_F1lze0Qs5mHQya7rlqgMeAyUSttTw,1588
+labs_agent_lib/observability/__init__.py,sha256=6IDRJEpHljjZiuV8NGpsD6qvU57dSsaEjz067tVTczw,478
+labs_agent_lib/observability/_jsonl_writer.py,sha256=uoRuCte8GrLuymS4TcqTgXzcBvhXWbwQnZDsStH2xXI,1303
+labs_agent_lib/observability/agent_transcript.py,sha256=SzCUOkQ5ASRYRRC2JdryogK6ovHzCqBsOavenQ7DpQw,5386
+labs_agent_lib/observability/prompt_log.py,sha256=dkVz-qrwEkBLn4q4Pi4Bx5m5NoMOJv1syapesfWlewE,2229
+labs_agent_lib-0.1.0.dist-info/licenses/LICENSE,sha256=IGiwkyXXQSAmCP3-U_MxnvtRsVwAdr_QE8JtR_gYW40,1107
+labs_agent_lib-0.1.0.dist-info/WHEEL,sha256=q9Wah2_CgP24mRNSlTyb0F8Yrbz55SzVl8eHLkZ_wvE,80
+labs_agent_lib-0.1.0.dist-info/METADATA,sha256=cwf5b63xRwOoR5HCubO5wQxUR4rNVFeyAEuOSeym0xo,3317
+labs_agent_lib-0.1.0.dist-info/RECORD,,

labs_agent_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.2
+Root-Is-Purelib: true
+Tag: py3-none-any

labs_agent_lib-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luis Alberto Bolaños Salazar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.