langchain-odile 0.1.0__tar.gz

langchain_odile-0.1.0/LICENSE

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

langchain_odile-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: langchain-odile
+Version: 0.1.0
+Summary: LangChain tools for Odile Direct
+Author-email: Odile Labs <hello@odilelabs.com>
+License: MIT
+Project-URL: Homepage, https://odilelabs.com/developers
+Project-URL: Source, https://github.com/tolga-boop/langchain-odile
+Keywords: langchain,mcp,odile,business,phone
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=0.3
+Dynamic: license-file
+
+# langchain-odile
+
+LangChain tools for finding a business by phone and sending requests through Odile Direct.
+
+```sh
+pip install langchain-odile
+```
+
+```python
+from langchain.agents import create_agent
+from langchain_odile import OdileDirectToolkit
+
+# Supply a LangChain-compatible model and, optionally, a Direct API key.
+toolkit = OdileDirectToolkit(api_key="YOUR_API_KEY")
+tools = toolkit.get_tools()
+agent = create_agent(model=model, tools=tools)
+result = agent.invoke({
+    "messages": [{"role": "user", "content": "Find +15615550123"}]
+})
+print(result)
+```
+
+Lookups need no API key. See the [developer documentation](https://odilelabs.com/developers)
+and [pricing](https://odilelabs.com/pricing).

langchain_odile-0.1.0/README.md

@@ -0,0 +1,24 @@
+# langchain-odile
+
+LangChain tools for finding a business by phone and sending requests through Odile Direct.
+
+```sh
+pip install langchain-odile
+```
+
+```python
+from langchain.agents import create_agent
+from langchain_odile import OdileDirectToolkit
+
+# Supply a LangChain-compatible model and, optionally, a Direct API key.
+toolkit = OdileDirectToolkit(api_key="YOUR_API_KEY")
+tools = toolkit.get_tools()
+agent = create_agent(model=model, tools=tools)
+result = agent.invoke({
+    "messages": [{"role": "user", "content": "Find +15615550123"}]
+})
+print(result)
+```
+
+Lookups need no API key. See the [developer documentation](https://odilelabs.com/developers)
+and [pricing](https://odilelabs.com/pricing).

langchain_odile-0.1.0/langchain_odile/__init__.py

@@ -0,0 +1,7 @@
+"""Odile Direct tools for LangChain."""
+
+from .client import OdileDirectClient, OdileError
+from .toolkit import OdileDirectToolkit
+
+__version__ = "0.1.0"
+__all__ = ["OdileDirectToolkit", "OdileDirectClient", "OdileError", "__version__"]

langchain_odile-0.1.0/langchain_odile/client.py

@@ -0,0 +1,58 @@
+"""HTTP client for Odile Direct."""
+
+import json
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+
+class OdileError(Exception):
+    def __init__(self, code, message):
+        self.code = code
+        self.message = message
+        super().__init__(f"{code}: {message}")
+
+
+class OdileDirectClient:
+    def __init__(self, base_url="https://odilelabs.com/mcp/direct", api_key=None, timeout=30, fetch=None):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.timeout = timeout
+        self.fetch = fetch or self._fetch
+
+    def _fetch(self, request):
+        try:
+            with urlopen(request, timeout=self.timeout) as response:
+                return response.status, response.read()
+        except HTTPError as error:
+            return error.code, error.read()
+
+    def call(self, tool, arguments):
+        headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        request = Request(self.base_url, data=json.dumps({
+            "jsonrpc": "2.0", "id": 1, "method": "tools/call",
+            "params": {"name": tool, "arguments": arguments},
+        }).encode(), headers=headers, method="POST")
+        status, body = self.fetch(request)
+        try:
+            response = json.loads(body)
+        except (ValueError, UnicodeDecodeError):
+            if not 200 <= status < 300:
+                raise OdileError(status, body.decode("utf-8", errors="replace"))
+            raise
+        if not 200 <= status < 300:
+            error = response.get("error", response)
+            message = error.get("message", str(error)) if isinstance(error, dict) else str(error)
+            raise OdileError(status, message)
+        if "error" in response:
+            error = response["error"]
+            raise OdileError(error.get("code"), error.get("message", ""))
+        result = response["result"]
+        if "structuredContent" in result:
+            return result["structuredContent"]
+        content = "\n".join(part["text"] for part in result.get("content", []) if part.get("type") == "text")
+        try:
+            return json.loads(content)
+        except ValueError:
+            return content

langchain_odile-0.1.0/langchain_odile/direct-tools.json

@@ -0,0 +1,294 @@
+{
+ "get_m2m_network": {
+  "description": "Read the OdileM2M network card for Direct: the live skills a business can accept, what each costs in credits, the credit packs, the limits that apply, and the Gate MCP address and quickstart. Use it to cost Direct tasks before sending any. It does not choose between products (get_agent_services) and does not show your own balance (get_direct_usage). Returns the pricing card (currency, credit_cents, packs, lookups) plus live_skills[{id, name, description, credits}], receipts, mcp_url, gate_mcp_url, quickstart_url, docs_url and connect_steps[]. Reference data, nothing account-specific: takes no arguments, needs no sign-in, contacts no business and changes nothing. Example: call it once with no arguments before the first send_to_business of a session.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {}
+  }
+ },
+ "find_business_agent": {
+  "description": "Look up a business by its phone number in the Odile Direct directory and get its Direct card. Start here: send_to_business needs the business id (<biz>) from this card. Pass the number as customers dial it, in E.164 with the country code and no spaces or dashes (+15615550123); any other format is rejected. Returns {agent_card, business, trade, town}: agent_card is the A2A card URL (/b/<biz>/ for a business line, /c/<biz>/ for a claimed listing; pass that <biz> to send_to_business), and the card lists the skills the business accepts. A number that is not on Direct returns not_found with claim_url and listings_url; for a US or Canadian number, voice_fallback says whether call_business is available. Capped at 30 lookups per IP per hour without sign-in and 10000 per key per day signed in. Read-only; contacts no business. Example: number='+15615550123' returns the card whose id you pass to send_to_business as biz.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "number": {
+     "type": "string",
+     "pattern": "^\\+[1-9]\\d{6,14}$",
+     "description": "The business's phone number in E.164, e.g. +15615550123."
+    }
+   },
+   "required": [
+    "number"
+   ]
+  }
+ },
+ "send_to_business": {
+  "description": "Send one request to a business found with find_business_agent, using a skill its card lists: take_message (leave a message), check_availability (read open times), book (book a slot check_availability returned), book_first_available (book the first open slot in up to 5 preferred windows) or cancel_booking (cancel a booking you made). Call find_business_agent first; for a business without a card, use call_business. Say an automated assistant is acting, and get the person's permission before booking. A delivered message cannot be recalled; a booking is undone only with cancel_booking. message_id is the retry key: reuse it unchanged on every retry so the request runs once. If you omit it, an identical request from you counts as a retry only within the same UTC day. Returns the A2A v1.0 {task}: read its state before telling anyone a message was delivered or a booking confirmed. A deposit booking returns INPUT_REQUIRED with a payment_url for the person; it is held 30 minutes and confirmed only after payment, which get_direct_payment checks. Failed, refused and unconfirmed tasks are not charged; costs are in get_m2m_network and your balance in get_direct_usage. Messages and confirmed bookings return thread_id and thread_token: use get_replies to read the business\u2019s replies and reply_to_business to answer in the same conversation. Signed-in requesters may omit callback_number for take_message; anonymous requesters still need their own valid number. Example: biz='harbor-plumbing', skill='take_message', message_id='req-8f2', data={caller_name:'Ana Diaz', callback_number:'+15615550199', need:'Leaking water heater, today if possible'}.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "biz": {
+     "type": "string",
+     "pattern": "^[a-zA-Z0-9_-]{1,100}$",
+     "description": "The business id from its card: the <biz> in /b/<biz>/ or /c/<biz>/."
+    },
+    "target": {
+     "description": "line (default) for a business line (/b/ card); claim for a claimed listing (/c/ card), which takes messages only.",
+     "type": "string",
+     "enum": [
+      "line",
+      "claim"
+     ]
+    },
+    "message_id": {
+     "description": "Your id for this request; reuse it unchanged on every retry so the request runs once.",
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 160
+    },
+    "approval_id": {
+     "description": "Only when the business approves bookings itself: the action_id (da_...) from its approval_required reply, sent with the same message_id and data once the owner approves.",
+     "type": "string",
+     "pattern": "^da_[a-f0-9]{24}$"
+    },
+    "skill": {
+     "type": "string",
+     "enum": [
+      "take_message",
+      "check_availability",
+      "book",
+      "book_first_available",
+      "cancel_booking"
+     ],
+     "description": "One skill the business card lists."
+    },
+    "data": {
+     "type": "object",
+     "propertyNames": {
+      "type": "string"
+     },
+     "additionalProperties": {},
+     "description": "The skill's fields; put skill beside data, never inside it. take_message: caller_name, callback_number (the person's own E.164 number, never the business's), need, optional on_behalf_of and urgency (low, normal, high or urgent). check_availability: optional service and date (YYYY-MM-DD in the business's time zone). book: slot exactly as check_availability returned it, caller_name, callback_number, need. book_first_available: options (1 to 5 windows in order, each {date, optional after and before as HH:MM, optional service}), fallback (none or take_message), caller_name, callback_number, need. cancel_booking: booking_id and cancel_token from the confirmed booking, optional reason (up to 300 characters); cancelling is not charged and does not refund a booking fee. For take_message only, a signed-in requester may omit callback_number and receive replies in the thread."
+    }
+   },
+   "required": [
+    "biz",
+    "skill",
+    "data"
+   ]
+  }
+ },
+ "get_replies": {
+  "description": "Read the replies in a Direct conversation you started with send_to_business: its status and messages, newest last. Use it to find out whether the business has answered; it only reads and does not wait, so call it again later if there is no reply yet. Not for messages callers left on your own answering line (get_line_messages) or the outcome of a phone call (get_call_result). Pass the thread_id that send_to_business returned; sign in as the original requester with direct:tasks, or supply the private thread_token instead. Returns {thread_id, status (received, business_notified, business_replied, booked, waiting_for_you or closed), caller_name, callback_number, messages[{from: customer or business, text, at}]}. An unknown thread or a wrong token returns not_found, and a thread expires 90 days after its last message. Changes nothing and uses no credits. Example: thread_id='th_7c1' (with thread_token unless you started the thread while signed in) returns the status and messages so far.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "thread_id": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 160,
+     "description": "The thread_id returned by send_to_business."
+    },
+    "thread_token": {
+     "description": "The private thread_token; required unless signed in as the requester who started the thread.",
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 128
+    }
+   },
+   "required": [
+    "thread_id"
+   ]
+  }
+ },
+ "reply_to_business": {
+  "description": "Send a customer reply in an open Direct conversation and notify the business. Use it after get_replies shows the business answered or asked something; to start a new conversation use send_to_business, and to answer a question during a live phone call use answer_call_question. Pass the thread_id that send_to_business returned and the reply text (1 to 500 characters); sign in as the original requester with direct:tasks, or supply the private thread_token instead. message_id is the retry key: reuse it unchanged when retrying. Returns the A2A {task} for the reply: read its state before telling anyone it was delivered. A delivered reply cannot be recalled and is billed the same way as a take_message task; closed conversations refuse replies. Example: thread_id='th_7c1', text='Thursday after 2pm works, thank you.', message_id='rep-1'.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "thread_id": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 160,
+     "description": "The thread_id returned by send_to_business."
+    },
+    "thread_token": {
+     "description": "The private thread_token; required unless signed in as the requester who started the thread.",
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 128
+    },
+    "text": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 500,
+     "description": "The customer\u2019s reply to the business."
+    },
+    "message_id": {
+     "description": "Your id for this reply; reuse it unchanged when retrying.",
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 160
+    }
+   },
+   "required": [
+    "thread_id",
+    "text"
+   ]
+  }
+ },
+ "call_business": {
+  "description": "Place an outbound phone call to a business to ask for information on a named person\u2019s behalf. Use it when find_business_agent returned not_found for a US or Canadian number; when a Direct card exists use send_to_business. It dials a real number and a call cannot be recalled once placed. Requires direct:tasks, human opt-in at https://odilelabs.com/developers#voice and the person\u2019s permission for this call (on_behalf_consent true). Informational calls only: no sales, payments or account access. Calls run Monday to Friday, 9:00 to 17:00 in the business\u2019s local time; outside that window the request is refused and the error includes next_window. A number is not called twice within 24 hours, and each account has a daily call cap. number and callback_number must be callable US or Canadian E.164 numbers, callback_number being the person\u2019s own, never the business\u2019s. message_id is required: reuse it unchanged on every retry so only one call is placed. Returns {task_id, state (queued, completed or failed), status}; read get_call_result for progress and answers. Voice credit costs: get_m2m_network. Example: number='+15615550123', business_name='Harbor Plumbing', caller_name='Ana Diaz', callback_number='+15615550199', need='Do you replace water heaters?', on_behalf_consent=true, message_id='call-8f2'.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "number": {
+     "type": "string",
+     "pattern": "^\\+[1-9]\\d{6,14}$",
+     "description": "The business\u2019s E.164 phone number, e.g. +15615550123."
+    },
+    "business_name": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 120,
+     "description": "The business to call."
+    },
+    "caller_name": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 100,
+     "description": "The named person who requested this call."
+    },
+    "callback_number": {
+     "type": "string",
+     "pattern": "^\\+[1-9]\\d{6,14}$",
+     "description": "That person\u2019s own callback number in E.164, never the business\u2019s."
+    },
+    "need": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 500,
+     "description": "The information the person wants from the business."
+    },
+    "on_behalf_consent": {
+     "type": "boolean",
+     "const": true,
+     "description": "True only after that person asked for this call."
+    },
+    "questions": {
+     "description": "Up to five questions to ask the business.",
+     "maxItems": 5,
+     "type": "array",
+     "items": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 200
+     }
+    },
+    "message_id": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 160,
+     "description": "A stable request id; reuse it unchanged on every retry."
+    },
+    "max_seconds": {
+     "description": "Maximum call duration, from 60 to 600 seconds, subject to available credits.",
+     "type": "integer",
+     "minimum": 60,
+     "maximum": 600
+    }
+   },
+   "required": [
+    "number",
+    "business_name",
+    "caller_name",
+    "callback_number",
+    "need",
+    "on_behalf_consent",
+    "message_id"
+   ]
+  }
+ },
+ "get_call_result": {
+  "description": "Read the state and outcome of a business call you placed with call_business (an outbound call; the calls your own answering line took are in get_line_calls), using its task_id. Call it again until the state is final: queued, dialing and in_call are still in progress; completed, no_answer, voicemail, refused and failed are final; input_required means the business asked a question that answer_call_question can answer within 45 seconds. Requires direct:tasks and ownership of the call (another account\u2019s task_id returns Not found). Returns {task_id, state, outcome, duration_seconds, transcript, answers, summary, cost {credits}}, plus pending_question {question, expires_at} while a question waits. Changes nothing, starts no call and is safe to repeat. Example: task_id='dv_9a3' from call_business; stop polling once state is completed, failed or no_answer.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "task_id": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 100,
+     "description": "The task_id returned by call_business."
+    }
+   },
+   "required": [
+    "task_id"
+   ]
+  }
+ },
+ "answer_call_question": {
+  "description": "Give the calling assistant your answer to a question the business asked during a call placed with call_business, so the call can continue. Use it only when get_call_result shows state input_required (its pending_question holds the question); reply within 45 seconds or the assistant tells the business the person will follow up and carries on. The assistant uses the answer on the live call and it cannot be taken back, so keep it short and factual (up to 300 characters). It is refused if it contains a number of four to eight digits, a card-length number, or words such as password, PIN or code; never include payment card numbers, passwords or one-time codes. Requires direct:tasks and ownership of the call. Returns the call state; read get_call_result for the outcome. Example: task_id='dv_9a3', answer='A 40-gallon gas heater, installed in 2016.'",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "task_id": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 100,
+     "description": "The task_id returned by call_business."
+    },
+    "answer": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 300,
+     "description": "The answer to the pending question, in plain words, without card numbers, passwords, one-time codes or any number of four to eight digits."
+    }
+   },
+   "required": [
+    "task_id",
+    "answer"
+   ]
+  }
+ },
+ "get_direct_usage": {
+  "description": "Read your own Direct account ledger: the signed-in account\u2019s UTC free-send allowance, prepaid balance in cents, reserved cents and last 20 charges. It never buys credit and does not list costs (see get_m2m_network). Use it before sending tasks that may cost credit; a payment_required reply from send_to_business carries the top-up link. Uses the same ledger as REST and your developer page. Requires direct:tasks and sign-in. Changes nothing; phone minutes and legacy credits are tracked separately. Example: call it with no arguments before a booking to confirm the allowance or balance covers it.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {}
+  }
+ },
+ "get_direct_payment": {
+  "description": "Check an existing deposit booking on your signed-in Direct account: reconcile its Stripe Checkout payment and return its receipt and the separate booking state. Use it after send_to_business returned a payment_url for a deposit booking, to see whether the person has paid; it cannot start a payment, which the person makes on Stripe\u2019s hosted page. Pass biz (the business id from its card) and task_id (the task id send_to_business returned for that booking). Requires direct:tasks. Uses only the stored merchant account and amount and creates no new charge or booking identity; a verified paid checkout may finish its already-authorized held booking. Payout status remains unknown: paid does not mean a bank payout. Safe to repeat. Example: biz='harbor-plumbing', task_id='tk_5d0' after send_to_business returned a payment_url for a deposit booking.",
+  "inputSchema": {
+   "$schema": "http://json-schema.org/draft-07/schema#",
+   "type": "object",
+   "properties": {
+    "biz": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 100,
+     "description": "The business id (from its card) the deposit booking was made with."
+    },
+    "task_id": {
+     "type": "string",
+     "minLength": 1,
+     "maxLength": 100,
+     "description": "The task id send_to_business returned for that booking."
+    }
+   },
+   "required": [
+    "biz",
+    "task_id"
+   ]
+  }
+ }
+}

langchain_odile-0.1.0/langchain_odile/toolkit.py

@@ -0,0 +1,19 @@
+"""Toolkit for Odile Direct."""
+
+from langchain_core.tools import BaseToolkit
+from pydantic import ConfigDict, Field
+
+from .client import OdileDirectClient
+from .tools import make_tools
+
+
+class OdileDirectToolkit(BaseToolkit):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    client: OdileDirectClient = Field(exclude=True)
+
+    def __init__(self, api_key=None, base_url="https://odilelabs.com/mcp/direct", **kwargs):
+        client = kwargs.pop("client", None) or OdileDirectClient(base_url=base_url, api_key=api_key)
+        super().__init__(client=client, **kwargs)
+
+    def get_tools(self):
+        return make_tools(self.client)

langchain_odile-0.1.0/langchain_odile/tools.py

@@ -0,0 +1,48 @@
+"""LangChain tools from the Direct schemas."""
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Literal, Optional
+
+from langchain_core.tools import StructuredTool
+from pydantic import Field, create_model
+
+SCHEMAS = json.loads(Path(__file__).with_name("direct-tools.json").read_text(encoding="utf-8"))
+
+
+def _model(name, schema):
+    fields = {}
+    required = schema.get("required", [])
+    for key, spec in schema["properties"].items():
+        field_type = dict if spec["type"] == "object" else str
+        if "enum" in spec:
+            field_type = Literal[tuple(spec["enum"])]
+        if key not in required:
+            field_type = Optional[field_type]
+        description = spec.get("description", "")
+        if spec["type"] == "object":
+            description += " Schema: " + json.dumps(spec, sort_keys=True)
+        if name == "send_to_business" and key == "message_id":
+            description += " If omitted, a deterministic SHA-256 retry key is derived from biz, skill and data."
+        constraints = {target: spec[source] for source, target in (
+            ("pattern", "pattern"), ("minLength", "min_length"), ("maxLength", "max_length")
+        ) if source in spec}
+        fields[key] = (field_type, Field(... if key in required else None, description=description, **constraints))
+    return create_model(name + "_args", **fields)
+
+
+def make_tools(client):
+    def bind(name):
+        def call(**arguments):
+            arguments = {key: value for key, value in arguments.items() if value is not None}
+            if name == "send_to_business" and "message_id" not in arguments:
+                value = arguments["biz"] + arguments["skill"] + json.dumps(arguments["data"], sort_keys=True)
+                arguments["message_id"] = hashlib.sha256(value.encode()).hexdigest()[:40]
+            return client.call(name, arguments)
+        return call
+
+    return [StructuredTool.from_function(
+        func=bind(name), name=name, description=definition["description"],
+        args_schema=_model(name, definition["inputSchema"]),
+    ) for name, definition in SCHEMAS.items()]

langchain_odile-0.1.0/langchain_odile.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: langchain-odile
+Version: 0.1.0
+Summary: LangChain tools for Odile Direct
+Author-email: Odile Labs <hello@odilelabs.com>
+License: MIT
+Project-URL: Homepage, https://odilelabs.com/developers
+Project-URL: Source, https://github.com/tolga-boop/langchain-odile
+Keywords: langchain,mcp,odile,business,phone
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=0.3
+Dynamic: license-file
+
+# langchain-odile
+
+LangChain tools for finding a business by phone and sending requests through Odile Direct.
+
+```sh
+pip install langchain-odile
+```
+
+```python
+from langchain.agents import create_agent
+from langchain_odile import OdileDirectToolkit
+
+# Supply a LangChain-compatible model and, optionally, a Direct API key.
+toolkit = OdileDirectToolkit(api_key="YOUR_API_KEY")
+tools = toolkit.get_tools()
+agent = create_agent(model=model, tools=tools)
+result = agent.invoke({
+    "messages": [{"role": "user", "content": "Find +15615550123"}]
+})
+print(result)
+```
+
+Lookups need no API key. See the [developer documentation](https://odilelabs.com/developers)
+and [pricing](https://odilelabs.com/pricing).

langchain_odile-0.1.0/langchain_odile.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_odile/__init__.py
+langchain_odile/client.py
+langchain_odile/direct-tools.json
+langchain_odile/toolkit.py
+langchain_odile/tools.py
+langchain_odile.egg-info/PKG-INFO
+langchain_odile.egg-info/SOURCES.txt
+langchain_odile.egg-info/dependency_links.txt
+langchain_odile.egg-info/requires.txt
+langchain_odile.egg-info/top_level.txt
+tests/test_client.py
+tests/test_tools.py

langchain_odile-0.1.0/langchain_odile.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_odile-0.1.0/langchain_odile.egg-info/requires.txt

@@ -0,0 +1 @@
+langchain-core>=0.3

langchain_odile-0.1.0/langchain_odile.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_odile

langchain_odile-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-odile"
+version = "0.1.0"
+description = "LangChain tools for Odile Direct"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["langchain-core>=0.3"]
+license = {text = "MIT"}
+authors = [{name = "Odile Labs", email = "hello@odilelabs.com"}]
+keywords = ["langchain", "mcp", "odile", "business", "phone"]
+
+[project.urls]
+Homepage = "https://odilelabs.com/developers"
+Source = "https://github.com/tolga-boop/langchain-odile"
+
+[tool.setuptools.package-data]
+langchain_odile = ["direct-tools.json"]

langchain_odile-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langchain_odile-0.1.0/tests/test_client.py

@@ -0,0 +1,70 @@
+import json
+import unittest
+from unittest.mock import patch
+from urllib.error import HTTPError
+from io import BytesIO
+
+from langchain_odile import OdileDirectClient, OdileError
+
+
+class ClientTests(unittest.TestCase):
+    def test_envelope_and_headers(self):
+        for key in (None, "test-key"):
+            with self.subTest(key=key):
+                requests = []
+                def fetch(request):
+                    requests.append(request)
+                    return 200, b'{"result":{"content":[{"type":"text","text":"ok"}]}}'
+                client = OdileDirectClient(base_url="https://example.test/mcp", api_key=key, fetch=fetch)
+                self.assertEqual(client.call("find_business_agent", {"number": "+15615550123"}), "ok")
+                req = requests[0]
+                self.assertEqual(req.full_url, "https://example.test/mcp")
+                self.assertEqual(req.get_method(), "POST")
+                self.assertEqual(dict(req.header_items()), {
+                    "Content-type": "application/json", "Accept": "application/json, text/event-stream",
+                    **({"Authorization": "Bearer test-key"} if key else {}),
+                })
+                self.assertEqual(json.loads(req.data), {"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {
+                    "name": "find_business_agent", "arguments": {"number": "+15615550123"}}})
+
+    def test_structured_content_takes_precedence_even_when_empty(self):
+        client = OdileDirectClient(fetch=lambda _: (200, b'{"result":{"structuredContent":{},"content":[{"type":"text","text":"ignored"}]}}'))
+        self.assertEqual(client.call("x", {}), {})
+
+    def test_text_parts_join_and_parse_json(self):
+        result = {"result": {"content": [{"type": "text", "text": '{"ok":'}, {"type": "image"}, {"type": "text", "text": "true}"}]}}
+        client = OdileDirectClient(fetch=lambda _: (200, json.dumps(result).encode()))
+        self.assertEqual(client.call("x", {}), {"ok": True})
+
+    def test_text_fallback(self):
+        client = OdileDirectClient(fetch=lambda _: (200, b'{"result":{"content":[{"type":"text","text":"hello"},{"type":"text","text":"world"}]}}'))
+        self.assertEqual(client.call("x", {}), "hello\nworld")
+
+    def test_rpc_error(self):
+        client = OdileDirectClient(fetch=lambda _: (200, b'{"error":{"code":-32602,"message":"bad arguments"}}'))
+        with self.assertRaises(OdileError) as caught:
+            client.call("x", {})
+        self.assertEqual((caught.exception.code, caught.exception.message), (-32602, "bad arguments"))
+
+    def test_http_errors(self):
+        for status in (402, 429):
+            with self.subTest(status=status):
+                client = OdileDirectClient(fetch=lambda _: (status, b'{"error":{"message":"server says no"}}'))
+                with self.assertRaises(OdileError) as caught:
+                    client.call("x", {})
+                self.assertEqual((caught.exception.code, caught.exception.message), (status, "server says no"))
+
+    def test_http_plain_error(self):
+        client = OdileDirectClient(fetch=lambda _: (503, b"unavailable"))
+        with self.assertRaises(OdileError) as caught:
+            client.call("x", {})
+        self.assertEqual((caught.exception.code, caught.exception.message), (503, "unavailable"))
+
+    def test_real_fetch_passes_timeout_and_handles_http_error(self):
+        error = HTTPError("https://example.test", 429, "Too Many", {}, BytesIO(b'{"message":"slow down"}'))
+        with patch("langchain_odile.client.urlopen", side_effect=error) as urlopen:
+            with self.assertRaises(OdileError) as caught:
+                OdileDirectClient(timeout=7).call("x", {})
+        error.close()
+        self.assertEqual(caught.exception.message, "slow down")
+        self.assertEqual(urlopen.call_args.kwargs["timeout"], 7)

langchain_odile-0.1.0/tests/test_tools.py

@@ -0,0 +1,79 @@
+import hashlib
+import json
+import unittest
+from pathlib import Path
+
+from langchain_core.tools import StructuredTool
+from pydantic import ValidationError
+
+from langchain_odile import OdileDirectClient, OdileDirectToolkit, __version__
+
+
+class ToolTests(unittest.TestCase):
+    def setUp(self):
+        self.calls = []
+        self.client = OdileDirectClient(fetch=lambda request: self._fetch(request))
+        self.toolkit = OdileDirectToolkit(client=self.client)
+        self.tools = {tool.name: tool for tool in self.toolkit.get_tools()}
+        self.schemas = json.loads(Path("langchain_odile/direct-tools.json").read_text())
+
+    def _fetch(self, request):
+        self.calls.append(json.loads(request.data)["params"])
+        return 200, b'{"result":{"structuredContent":{"ok":true}}}'
+
+    def test_all_tools_names_descriptions_and_types(self):
+        self.assertEqual(set(self.tools), set(self.schemas))
+        self.assertEqual(len(self.toolkit.get_tools()), len(self.schemas))
+        for name, tool in self.tools.items():
+            self.assertIsInstance(tool, StructuredTool)
+            self.assertEqual(tool.description, self.schemas[name]["description"])
+            self.assertEqual(set(tool.args_schema.model_json_schema().get("required", [])),
+                             set(self.schemas[name]["inputSchema"].get("required", [])))
+        self.assertEqual(__version__, "0.1.0")
+
+    def test_missing_every_required_field(self):
+        def example(prop):   # one value that satisfies the server's own constraints for that property
+            if "enum" in prop: return prop["enum"][0]
+            if prop.get("type") == "object": return {}
+            if prop.get("type") == "integer": return 1
+            if prop.get("type") == "boolean": return True
+            if prop.get("pattern", "").startswith("^\\+"): return "+15615550123"
+            return "harbor"
+        for name, tool in self.tools.items():
+            props = self.schemas[name]["inputSchema"].get("properties", {})
+            valid = {key: example(props[key]) for key in self.schemas[name]["inputSchema"].get("required", [])}
+            for key in valid:
+                with self.subTest(tool=name, missing=key), self.assertRaises(ValidationError):
+                    tool.invoke({k: v for k, v in valid.items() if k != key})
+        self.assertEqual(self.calls, [])
+
+    def test_patterns_enums_and_lengths(self):
+        for number in ("15615550123", "+01234567", "+1 5615550123"):
+            with self.subTest(number=number), self.assertRaises(ValidationError):
+                self.tools["find_business_agent"].invoke({"number": number})
+        base = {"biz": "harbor", "skill": "take_message", "data": {}}
+        for override in ({"biz": "bad id"}, {"skill": "unknown"}, {"target": "other"},
+                         {"message_id": ""}, {"message_id": "x" * 161}, {"approval_id": "bad"}):
+            with self.subTest(override=override), self.assertRaises(ValidationError):
+                self.tools["send_to_business"].invoke({**base, **override})
+        self.assertEqual(self.calls, [])
+
+    def test_send_derives_stable_id_and_keeps_supplied_id(self):
+        tool = self.tools["send_to_business"]
+        args = {"biz": "harbor", "skill": "take_message", "data": {"b": 2, "a": 1}}
+        self.assertEqual(tool.invoke(args), {"ok": True})
+        tool.invoke({**args, "data": {"a": 1, "b": 2}})
+        expected = hashlib.sha256((args["biz"] + args["skill"] + json.dumps(args["data"], sort_keys=True)).encode()).hexdigest()[:40]
+        self.assertEqual([c["arguments"]["message_id"] for c in self.calls], [expected, expected])
+        tool.invoke({**args, "message_id": "supplied"})
+        self.assertEqual(self.calls[-1]["arguments"]["message_id"], "supplied")
+        description = tool.args_schema.model_fields["message_id"].description
+        self.assertIn("deterministic", description)
+        self.assertIn('"type": "object"', tool.args_schema.model_fields["data"].description)
+
+    def test_tools_share_client_and_constructor_options(self):
+        self.tools["find_business_agent"].invoke({"number": "+15615550123"})
+        self.tools["send_to_business"].invoke({"biz": "x", "skill": "take_message", "data": {}})
+        self.assertEqual([c["name"] for c in self.calls], ["find_business_agent", "send_to_business"])
+        toolkit = OdileDirectToolkit(base_url="https://example.test", api_key="key")
+        self.assertEqual((toolkit.client.base_url, toolkit.client.api_key), ("https://example.test", "key"))