answerline-langchain 0.1.0__py3-none-any.whl

answerline_langchain/__init__.py

@@ -0,0 +1,84 @@
+"""LangChain tools for the answer and search monitoring API, built on the `answerline` client."""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+from typing import Any, Callable, Dict, Iterable, List, Literal, Optional, Sequence, Union
+
+from answerline import ApiError, Client
+from langchain_core.tools import BaseTool, StructuredTool, ToolException
+from pydantic import BaseModel, create_model
+
+from .input import Input, Operation
+from .schemas import CREATE_ASYNC_TASK, GET_CREDITS, GET_TASK_STATUS, MONITOR_OPERATIONS
+
+__all__ = ["create_tools"]
+
+Call = Callable[[Dict[str, Any]], Any]
+
+
+def create_tools(client: Client, engines: Optional[Iterable[str]] = None) -> List[BaseTool]:
+    """A sync monitor tool per served engine, plus async task submission, task status and credits.
+
+    `engines` lists the task types the deployment serves (its `served_engines`); every priced engine by default.
+    """
+    served = set(op.task_type for op in MONITOR_OPERATIONS) if engines is None else set(engines)
+    monitors = [op for op in MONITOR_OPERATIONS if op.task_type in served]
+    if not monitors or len(monitors) < len(served):
+        raise ValueError(f"engines must be priced engines, at least one: {sorted(served)}")
+
+    def monitor(route: str) -> Call:
+        return lambda body: client.monitor(route, **body)
+
+    def create_task(body: Dict[str, Any]) -> Any:
+        webhook = body.get("webhook")
+        webhook_url = webhook.get("url") if isinstance(webhook, dict) else None
+        return client.create_task(body["taskType"], body["payload"], body.get("priority"), body.get("idempotencyKey"), webhook_url)
+
+    return [
+        *(_tool(op, monitor(op.route)) for op in monitors),
+        _tool(dataclasses.replace(CREATE_ASYNC_TASK, args_schema=_task_schema(monitors)), create_task),
+        _tool(GET_TASK_STATUS, lambda body: client.get_task(body["taskId"])),
+        _tool(GET_CREDITS, lambda body: client.credits()),
+    ]
+
+
+def _task_schema(monitors: Sequence[Operation]) -> type[Input]:
+    """The async task input narrowed to the task types and payloads of `monitors`."""
+    schema = CREATE_ASYNC_TASK.args_schema
+    fields = schema.model_fields
+    return create_model(
+        schema.__name__,
+        __base__=schema,
+        taskType=(Literal[tuple(op.task_type for op in monitors)], fields["taskType"]),
+        payload=(Union[tuple(op.args_schema for op in monitors)], fields["payload"]),
+    )
+
+
+def _tool(operation: Operation, call: Call) -> BaseTool:
+    def run(**arguments: Any) -> Any:
+        try:
+            return call(_body(arguments))
+        # Handled as the tool's result, so the model sees why the call failed and can correct or retry it.
+        except ApiError as err:
+            raise ToolException(f"{err}: {json.dumps(err.body)}") from err
+        except OSError as err:
+            raise ToolException(f"request failed: {type(err).__name__}: {err}") from err
+
+    return StructuredTool.from_function(
+        func=run,
+        name=operation.name,
+        description=operation.description,
+        args_schema=operation.args_schema,
+        handle_tool_error=True,
+    )
+
+
+def _body(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Validated arguments as JSON. LangChain passes nested objects as models and omitted fields as None."""
+    return {
+        name: value.model_dump(exclude_none=True) if isinstance(value, BaseModel) else value
+        for name, value in arguments.items()
+        if value is not None
+    }

answerline_langchain/input.py

@@ -0,0 +1,40 @@
+"""Base types of the generated tool inputs in `schemas`."""
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, Optional, Tuple, Type
+
+from pydantic import BaseModel, ConfigDict, ValidationInfo, field_validator, model_validator
+
+
+class Input(BaseModel):
+    """A tool input. Unknown fields are refused, as the API refuses them."""
+
+    model_config = ConfigDict(extra="forbid")
+    # The schema's `anyOf`: every field of at least one of these sets must be given.
+    required_any_of: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
+    # An async task's payload model by task type.
+    payload_types: ClassVar[Dict[str, Type["Input"]]] = {}
+
+    @model_validator(mode="after")
+    def _check_required_any_of(self) -> "Input":
+        sets = self.required_any_of
+        if sets and not any(all(getattr(self, field) is not None for field in fields) for fields in sets):
+            raise ValueError("provide " + " or ".join(" and ".join(fields) for fields in sets))
+        return self
+
+    @field_validator("payload", mode="before", check_fields=False)
+    @classmethod
+    def _validate_payload_as_its_task_type(cls, payload: Any, info: ValidationInfo) -> Any:
+        # An invalid task type is reported on its own field; the payload is then left to its declared type.
+        payload_type = cls.payload_types.get(info.data.get("taskType"))
+        return payload_type.model_validate(payload) if payload_type else payload
+
+
+@dataclass(frozen=True)
+class Operation:
+    name: str
+    description: str
+    args_schema: Type[Input]
+    # Path under /v1/monitor/ and task type of a monitor operation.
+    route: Optional[str] = None
+    task_type: Optional[str] = None

answerline_langchain/schemas.py

@@ -0,0 +1,169 @@
+# Generated by integrations/codegen from openapi/openapi.json and config/pricing.toml. Do not edit.
+from typing import Literal, Optional, Union
+
+from pydantic import Field
+
+from .input import Input, Operation
+
+
+class MonitorChatgptInputInclude(Input):
+    html: Optional[bool] = Field(None, description="Include a URL to the full HTML of the response")
+    markdown: Optional[bool] = Field(None, description="Include markdown-formatted response in the result")
+    rawResponse: Optional[bool] = Field(None, description="Include ChatGPT's raw response payload")
+    searchQueries: Optional[bool] = Field(None, description="Include the query fan-out ChatGPT used to generate the response")
+    ads: Optional[bool] = Field(None, description="Include ads displayed in ChatGPT response")
+    shopping: Optional[bool] = Field(None, description="Include shopping cards and inline products with pricing and offers. Adds +2 credits to the base cost (shared with rawResponse, searchQueries, and ads — enabling any one or any combination adds the same +2).")
+
+
+class MonitorChatgptInput(Input):
+    prompt: str = Field(description="The prompt to send to ChatGPT", min_length=1, max_length=10000)
+    country: str = Field(description="Country/region code for localized response")
+    include: Optional[MonitorChatgptInputInclude] = Field(None, description="Optional flags for including additional response formats")
+    legacy: Optional[bool] = Field(None, description="Serve ChatGPT's legacy desktop interface instead of the default mobile-web one. The legacy interface streams the answer as an event stream, so `result.model`, `result.searchQueries` and `result.mapSearchQueries` are populated. Best-effort and temporary: OpenAI controls which interface it serves and can retire the legacy one at any time, so a request can still come back in the mobile-web shape. Handle both. Defaults to false.")
+    disableWebSearch: Optional[bool] = Field(None, description="Do not force ChatGPT's web search. answerline returns the answer ChatGPT gives on its own, which uses web search only when ChatGPT decides to, so `result.sources`, `result.citationPills` and `result.searchQueries` are often empty. Defaults to false: web search is forced on every request.")
+    state: Optional[str] = Field(None, description="State code for sub-country geo-targeting (e.g., \"CA\"). Only valid with country \"US\".", min_length=2, max_length=2, pattern="^[A-Z]{2}$")
+
+
+class MonitorGeminiInputInclude(Input):
+    markdown: Optional[bool] = Field(None, description="Include markdown-formatted response in the result")
+    html: Optional[bool] = Field(None, description="Include HTML-formatted response in the result")
+    rawResponse: Optional[bool] = Field(None, description="Include raw streaming response events")
+
+
+class MonitorGeminiInput(Input):
+    prompt: str = Field(description="The prompt to send to Gemini", min_length=1, max_length=10000)
+    country: str = Field(description="Country/region code for localized response")
+    include: Optional[MonitorGeminiInputInclude] = Field(None, description="Optional flags for including additional response formats")
+    state: Optional[str] = Field(None, description="State code for sub-country geo-targeting (e.g., \"CA\"). Only valid with country \"US\".", min_length=2, max_length=2, pattern="^[A-Z]{2}$")
+
+
+class MonitorPerplexityInputInclude(Input):
+    html: Optional[bool] = Field(None, description="Include a URL to the full HTML of the response")
+    markdown: Optional[bool] = Field(None, description="Include markdown-formatted response in the result")
+    rawResponse: Optional[bool] = Field(None, description="Include raw streaming response events")
+
+
+class MonitorPerplexityInput(Input):
+    prompt: str = Field(description="The prompt to send to Perplexity", min_length=1, max_length=10000)
+    country: str = Field(description="Country/region code for localized response")
+    include: Optional[MonitorPerplexityInputInclude] = Field(None, description="Optional flags for including additional response formats")
+    state: Optional[str] = Field(None, description="State code for sub-country geo-targeting (e.g., \"CA\"). Only valid with country \"US\".", min_length=2, max_length=2, pattern="^[A-Z]{2}$")
+
+
+class MonitorCopilotInputInclude(Input):
+    html: Optional[bool] = Field(None, description="Include a URL to the full HTML of the response")
+    markdown: Optional[bool] = Field(None, description="Include markdown-formatted response in the result")
+    rawResponse: Optional[bool] = Field(None, description="Include raw streaming response events")
+
+
+class MonitorCopilotInput(Input):
+    prompt: str = Field(description="The prompt to send to Copilot", min_length=1, max_length=10000)
+    country: str = Field(description="Country/region code for localized response")
+    include: Optional[MonitorCopilotInputInclude] = Field(None, description="Optional flags for including additional response formats")
+    state: Optional[str] = Field(None, description="State code for sub-country geo-targeting (e.g., \"CA\"). Only valid with country \"US\".", min_length=2, max_length=2, pattern="^[A-Z]{2}$")
+
+
+class MonitorAiModeInputInclude(Input):
+    html: Optional[bool] = Field(None, description="Include a URL to the full HTML of the response")
+    markdown: Optional[bool] = Field(None, description="Include markdown-formatted response in the result")
+    expandProducts: Optional[bool] = Field(None, description="Fetch merchant offers for the product clusters in the response and return them as 'result.productResults'. Clusters are deduplicated across shopping cards and inline products, and expansion covers at most 6 per scrape. Charges +1 credit per cluster returned, to a maximum of +6. Off by default.")
+
+
+class MonitorAiModeInput(Input):
+    prompt: str = Field(description="The prompt to send to AI Mode", min_length=1, max_length=10000)
+    country: Optional[str] = Field(None, description="Country/region code for localized response")
+    gl: Optional[str] = Field(None, description="Alternative to `country`, using Google's own parameter name for the result geography. Same ISO 3166-1 alpha-2 codes, accepted in either case (`us` or `US`), and must be a country the endpoint supports — see `GET /v1/countries`. Provide `country` or `gl`; sending both with different values is a `400`.")
+    hl: Optional[str] = Field(None, description="Interface language, as Google's own `hl` parameter (e.g. `en`, `de`, `pt-BR`). Free-form and case-insensitive — Google owns the list of codes. Overrides the language answerline derives from the country, so the interface language and the result geography can differ.")
+    location: Optional[str] = Field(None, description="Google canonical location name for geo-targeted results, in comma-separated format: 'City,Region,Country' (see https://developers.google.com/google-ads/api/reference/data/geotargets for all ~100,000 supported locations). Use alongside 'country' for city-level precision. Mutually exclusive with 'uule' — provide one or the other, not both.")
+    uule: Optional[str] = Field(None, description="Pre-encoded Google UULE string for precise geo-targeting. Use this when you have a pre-built UULE value instead of a location name. Mutually exclusive with 'location' — provide one or the other, not both.")
+    device: Optional[Literal["desktop", "mobile"]] = Field(None, description="Device type for search results")
+    include: Optional[MonitorAiModeInputInclude] = Field(None, description="Optional flags for including additional response formats")
+    required_any_of = (("country",), ("gl",))
+
+
+class MonitorGoogleInputIncludeAioverview(Input):
+    markdown: Optional[bool] = Field(None, description="Include AI Overview formatted as markdown")
+
+
+class MonitorGoogleInputInclude(Input):
+    html: Optional[bool] = Field(None, description="Include raw HTML response from Google search")
+    aioverview: Optional[MonitorGoogleInputIncludeAioverview] = Field(None, description="Include Google AI Overview in the response")
+    paaAioverview: Optional[bool] = Field(None, description="Hydrate AI-Overview-type People Also Ask items with markdown content and sources. No additional credit cost beyond the +2 AI Overview add-on; each hydrated item adds one scraper fetch (typically 1-2 per page), so responses take longer.")
+
+
+class MonitorGoogleInput(Input):
+    query: Optional[str] = Field(None, description="The search query to execute on Google. Required unless you supply 'url' instead — the two are mutually exclusive.", min_length=1, max_length=10000)
+    url: Optional[str] = Field(None, description="A complete Google web search URL to run instead of building the request from 'query' and the targeting fields. Must be an absolute http(s) URL on a Google web search host (google.com, google.co.uk, www.google.de, ...), with the path '/search' and a non-empty 'q'. Mutually exclusive with 'query', 'location', 'uule' and 'pages' — the URL owns those values. answerline applies a fixed set of query parameters — 'q', 'gl', 'hl', 'uule', 'num' (read as result depth), 'start', 'tbs' and 'safe' — and drops anything else. URLs carrying 'tbm' are rejected, because they target a Google vertical with its own endpoint and pricing (use POST /v1/monitor/google/news for tbm=nws).")
+    country: Optional[str] = Field(None, description="ISO 3166-1 alpha-2 country code for localized search results. Required in the standard request shape. When you supply 'url' instead, country is derived from the URL's 'gl' — pass it explicitly to override that, or when the URL has no 'gl'.")
+    gl: Optional[str] = Field(None, description="Alternative to `country`, using Google's own parameter name for the result geography. Same ISO 3166-1 alpha-2 codes, accepted in either case (`us` or `US`), and must be a country the endpoint supports — see `GET /v1/countries`. Provide `country` or `gl`; sending both with different values is a `400`.")
+    hl: Optional[str] = Field(None, description="Interface language, as Google's own `hl` parameter (e.g. `en`, `de`, `pt-BR`). Free-form and case-insensitive — Google owns the list of codes. Overrides the language answerline derives from the country, so the interface language and the result geography can differ.")
+    location: Optional[str] = Field(None, description="Google canonical location name for geo-targeted results, in comma-separated format: 'City,Region,Country' (see https://developers.google.com/google-ads/api/reference/data/geotargets for all ~100,000 supported locations). Use alongside 'country' for city-level precision. Mutually exclusive with 'uule' — provide one or the other, not both. Cannot be combined with 'url'.")
+    uule: Optional[str] = Field(None, description="Pre-encoded Google UULE string for precise geo-targeting. Use this when you have a pre-built UULE value instead of a location name. Mutually exclusive with 'location' — provide one or the other, not both. Cannot be combined with 'url'; put 'uule' in the URL's query string instead.")
+    device: Optional[Literal["desktop", "mobile", "ios", "android"]] = Field(None, description="Device the search is run from. 'desktop' returns the desktop SERP; 'ios' (Safari on iPhone), 'android' (Chrome on Android) and 'mobile' (alias for 'android') all return the mobile SERP.")
+    pages: Optional[int] = Field(None, description="Number of search results pages to scrape (1-10). Cannot be combined with 'url' — in that shape, depth comes from the URL's 'num' (rounded up to whole pages of 10, capped at 10 pages).", ge=1, le=10)
+    include: Optional[MonitorGoogleInputInclude] = Field(None, description="Optional flags for including additional response data")
+    required_any_of = (("query", "country"), ("query", "gl"), ("url",))
+
+
+class MonitorGoogleNewsInputInclude(Input):
+    html: Optional[bool] = Field(None, description="Include raw HTML response from Google News")
+
+
+class MonitorGoogleNewsInput(Input):
+    query: str = Field(description="The search query to execute on Google News", min_length=1, max_length=10000)
+    country: Optional[str] = Field(None, description="ISO 3166-1 alpha-2 country code for localized news results")
+    gl: Optional[str] = Field(None, description="Alternative to `country`, using Google's own parameter name for the result geography. Same ISO 3166-1 alpha-2 codes, accepted in either case (`us` or `US`), and must be a country the endpoint supports — see `GET /v1/countries`. Provide `country` or `gl`; sending both with different values is a `400`.")
+    hl: Optional[str] = Field(None, description="Interface language, as Google's own `hl` parameter (e.g. `en`, `de`, `pt-BR`). Free-form and case-insensitive — Google owns the list of codes. Overrides the language answerline derives from the country, so the interface language and the result geography can differ.")
+    device: Optional[Literal["desktop", "mobile", "ios", "android"]] = Field(None, description="Device the search is run from. 'desktop' returns the desktop news SERP; 'ios' (Safari on iPhone), 'android' (Chrome on Android) and 'mobile' (alias for 'android') all return the mobile news SERP.")
+    pages: Optional[int] = Field(None, description="Number of news results pages to scrape (1-10)", ge=1, le=10)
+    include: Optional[MonitorGoogleNewsInputInclude] = Field(None, description="Optional flags for including additional response data")
+    required_any_of = (("country",), ("gl",))
+
+
+class MonitorGrokInputInclude(Input):
+    markdown: Optional[bool] = Field(None, description="Include markdown-formatted response in the result")
+    html: Optional[bool] = Field(None, description="Include HTML-formatted response in the result")
+    rawResponse: Optional[bool] = Field(None, description="Include raw streaming response events")
+
+
+class MonitorGrokInput(Input):
+    prompt: str = Field(description="The prompt to send to Grok", min_length=1, max_length=10000)
+    country: str = Field(description="Country/region code for localized response")
+    include: Optional[MonitorGrokInputInclude] = Field(None, description="Optional flags for including additional response formats")
+    state: Optional[str] = Field(None, description="State code for sub-country geo-targeting (e.g., \"CA\"). Only valid with country \"US\".", min_length=2, max_length=2, pattern="^[A-Z]{2}$")
+
+
+class CreateAsyncTaskInputWebhook(Input):
+    url: str = Field(description="URL to receive the webhook POST request when the task completes.")
+
+
+class CreateAsyncTaskInput(Input):
+    taskType: Literal["CHATGPT", "GEMINI", "PERPLEXITY", "COPILOT", "AIMODE", "GOOGLE", "GOOGLE_NEWS", "GROK"] = Field(description="The AI provider to use for this task.")
+    payload: Union[MonitorChatgptInput, MonitorGeminiInput, MonitorPerplexityInput, MonitorCopilotInput, MonitorAiModeInput, MonitorGoogleInput, MonitorGoogleNewsInput, MonitorGrokInput] = Field(description="Provider-specific request payload. Must include at least `prompt` (or `query` for Google Search).")
+    priority: Optional[int] = Field(None, description="Task priority level (1-10). Higher numbers are processed first. Defaults to 1.", ge=1, le=10)
+    idempotencyKey: Optional[str] = Field(None, description="Unique string to prevent duplicate task creation. Must be unique across your account.")
+    webhook: Optional[CreateAsyncTaskInputWebhook] = Field(None, description="Webhook configuration for task completion notification.")
+    payload_types = {"CHATGPT": MonitorChatgptInput, "GEMINI": MonitorGeminiInput, "PERPLEXITY": MonitorPerplexityInput, "COPILOT": MonitorCopilotInput, "AIMODE": MonitorAiModeInput, "GOOGLE": MonitorGoogleInput, "GOOGLE_NEWS": MonitorGoogleNewsInput, "GROK": MonitorGrokInput}
+
+
+class GetTaskStatusInput(Input):
+    taskId: str = Field(description="The ID of the task to fetch.")
+
+
+class GetCreditsInput(Input):
+    pass
+
+
+MONITOR_OPERATIONS = (
+    Operation("monitor_chatgpt", "Extract structured data from ChatGPT — answer text, cited sources, shopping cards, brand entities, and ads — for any prompt across supported regions", MonitorChatgptInput, route="chatgpt", task_type="CHATGPT"),
+    Operation("monitor_gemini", "Extract structured data from Google Gemini — generated answer text and cited sources for any prompt, with Markdown and HTML export formats", MonitorGeminiInput, route="gemini", task_type="GEMINI"),
+    Operation("monitor_perplexity", "Extract structured data from Perplexity AI about your brand, products, or any topic across various regions", MonitorPerplexityInput, route="perplexity", task_type="PERPLEXITY"),
+    Operation("monitor_copilot", "Extract structured data from Microsoft Copilot about your brand, products, or any topic across various regions", MonitorCopilotInput, route="copilot", task_type="COPILOT"),
+    Operation("monitor_ai_mode", "Extract structured data from AI Mode about your brand, products, or any topic across various regions", MonitorAiModeInput, route="aimode", task_type="AIMODE"),
+    Operation("monitor_google", "Extract structured data from Google Search including organic results, People Also Ask, related searches, and optional AI Overview", MonitorGoogleInput, route="google", task_type="GOOGLE"),
+    Operation("monitor_google_news", "Extract structured news articles from Google News including titles, links, snippets, sources, dates, and thumbnails", MonitorGoogleNewsInput, route="google/news", task_type="GOOGLE_NEWS"),
+    Operation("monitor_grok", "Extract structured data from Grok — answer text and cited sources, including X/Twitter references — for any prompt across supported regions", MonitorGrokInput, route="grok", task_type="GROK"),
+)
+CREATE_ASYNC_TASK = Operation("create_async_task", "Submit an asynchronous task for background processing. Returns a task ID that you can use to poll for results or receive via webhook.", CreateAsyncTaskInput)
+GET_TASK_STATUS = Operation("get_task_status", "Poll the status and result of an asynchronous task by ID. Returns the task state and, once complete, the full structured result payload.", GetTaskStatusInput)
+GET_CREDITS = Operation("get_credits", "Read your organization's current credit balance and billing cycle. Lets you observe your balance programmatically — including from async-only workloads — without making a sync /v1/monitor/* request just to inspect the X-Credits-Remaining header. The authoritative check is enforced when each task is charged.", GetCreditsInput)

answerline_langchain-0.1.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: answerline-langchain
+Version: 0.1.0
+Summary: LangChain tools for the AnswerLine answer and search monitoring API.
+Author-email: AnswerLine <support@answerline.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://answerline.dev
+Project-URL: Repository, https://github.com/hsdxpro/answerline
+Keywords: answerline,ai,llm,langchain,search-api,monitoring
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: answerline<0.2,>=0.1.0
+Requires-Dist: langchain-core<2,>=1.6.3
+Requires-Dist: pydantic<3,>=2.13.5
+Dynamic: license-file
+
+# answerline-langchain
+
+LangChain tools for the answer and search monitoring API, built on the Python SDK (`answerline`).
+
+```bash
+pip install answerline-langchain
+```
+
+`create_tools(client, engines=...)` returns one sync monitor tool per engine (`monitor_chatgpt`, `monitor_google_news`, ...), plus `create_async_task`, `get_task_status` and `get_credits`. `engines` lists the task types the deployment serves (its `served_engines`; the API refuses priced engines outside it) and defaults to every priced engine. An async task's `payload` is validated as the monitor request of its `taskType`. API errors, timeouts and connection errors come back to the model as the tool result.
+
+```python
+from answerline import Client
+from answerline_langchain import create_tools
+
+tools = create_tools(Client("sk_..."), engines=["CHATGPT"])
+```
+
+Tool input models in `src/answerline_langchain/schemas.py` are generated from `openapi/openapi.json` and the priced engines in `config/pricing.toml` by `integrations/codegen` (`npm run generate` there); do not edit them by hand.
+
+## Develop
+
+Until `answerline` is published, install the SDK from the repository:
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ../../sdk/python -e .
+```
+
+```bash
+.venv/bin/python -m unittest discover -s tests
+```
+
+Tests run offline against a local stub server.

answerline_langchain-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+answerline_langchain/__init__.py,sha256=__94UwSS_Ysuj2hEeVLRGKi7dXQZ5XkIkk9xnSOtpeM,3495
+answerline_langchain/input.py,sha256=OGbVe6yFPFyNiJ38tEMVX5d_1rbbrLvEW3HeaaqQ0UM,1684
+answerline_langchain/schemas.py,sha256=BRlfoiV8LNb9h3hIgwHEiEHcCqJRhiLraiCJQ4mmun4,18458
+answerline_langchain-0.1.0.dist-info/licenses/LICENSE,sha256=WEk3fXEcZoGoQtMd3Cu5aLyGrVtKajmtDHZaUlpSvEE,1067
+answerline_langchain-0.1.0.dist-info/METADATA,sha256=AE4v7IWbNgSYSWYSQQTdjU6JUHjhTrBMo5smlOPpAic,2249
+answerline_langchain-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+answerline_langchain-0.1.0.dist-info/top_level.txt,sha256=2QYzIAsb49Cn_Unl1AFJC6qX3SjhmuIk4RAAFBD180A,21
+answerline_langchain-0.1.0.dist-info/RECORD,,

answerline_langchain-0.1.0.dist-info/WHEEL

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

answerline_langchain-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AnswerLine
+
+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.

answerline_langchain-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+answerline_langchain