construct-labs-crm-env 0.1.8__tar.gz → 0.1.10__tar.gz

{construct_labs_crm_env-0.1.8 → construct_labs_crm_env-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: construct-labs-crm-env
-Version: 0.1.8
+Version: 0.1.10
 Summary: CRM Agent Environment SDK by Construct Labs - Train RL agents to interact with CRM systems
 Project-URL: Homepage, https://construct-labs.com
 Author-email: Construct Labs GmbH <hello@construct-labs.com>
@@ -23,7 +23,7 @@ Requires-Dist: openenv-core>=0.2.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: websockets>=12.0
 Provides-Extra: chat
-Requires-Dist: google-genai>=1.0.0; extra == 'chat'
+Requires-Dist: openai>=1.0.0; extra == 'chat'
 Requires-Dist: python-dotenv>=1.0.0; extra == 'chat'
 Provides-Extra: dev
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
@@ -44,7 +44,20 @@ Contact hello@construct-labs.com for licensing inquiries.
 ## Installation
 
 ```bash
-pip install construct-labs-crm-env
+uv add construct-labs-crm-env
+```
+
+## Try the Example Chat Agent
+
+Run the interactive chat agent without installing:
+
+```bash
+# OpenRouter API key (https://openrouter.ai/keys)
+export OPENAI_API_KEY=<api_key>
+# Construct Labs CRM API Key (provided by Construct Labs)
+export CRM_AGENT_API_KEY=<api_key> 
+
+uvx --from construct-labs-crm-env[chat] chat-agent
 ```
 
 ## Quick Start

{construct_labs_crm_env-0.1.8 → construct_labs_crm_env-0.1.10}/README.md

@@ -10,7 +10,20 @@ Contact hello@construct-labs.com for licensing inquiries.
 ## Installation
 
 ```bash
-pip install construct-labs-crm-env
+uv add construct-labs-crm-env
+```
+
+## Try the Example Chat Agent
+
+Run the interactive chat agent without installing:
+
+```bash
+# OpenRouter API key (https://openrouter.ai/keys)
+export OPENAI_API_KEY=<api_key>
+# Construct Labs CRM API Key (provided by Construct Labs)
+export CRM_AGENT_API_KEY=<api_key> 
+
+uvx --from construct-labs-crm-env[chat] chat-agent
 ```
 
 ## Quick Start

{construct_labs_crm_env-0.1.8 → construct_labs_crm_env-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "construct-labs-crm-env"
-version = "0.1.8"
+version = "0.1.10"
 description = "CRM Agent Environment SDK by Construct Labs - Train RL agents to interact with CRM systems"
 readme = "README.md"
 license = { text = "Proprietary" }
@@ -44,7 +44,7 @@ chat-agent = "construct_labs_crm_env.examples.chat:main"
 
 [project.optional-dependencies]
 chat = [
-    "google-genai>=1.0.0",
+    "openai>=1.0.0",
     "python-dotenv>=1.0.0",
 ]
 dev = [

{construct_labs_crm_env-0.1.8 → construct_labs_crm_env-0.1.10}/src/construct_labs_crm_env/examples/chat.py

@@ -6,15 +6,18 @@ the CRM environment tools. The LLM can make multiple tool calls to query
 and modify CRM data before providing a final answer.
 
 Requirements:
-    pip install construct-labs-crm-env google-genai python-dotenv
+    pip install construct-labs-crm-env openai python-dotenv
 
 Usage:
     export CRM_AGENT_API_KEY=your-crm-api-key
-    export GOOGLE_API_KEY=your-google-api-key
+    export OPENAI_API_KEY=your-openrouter-api-key
     python chat.py --help
     python chat.py
     python chat.py --question "How many companies are there?"
-    python chat.py --model gemini-2.0-flash --stream
+    python chat.py --model anthropic/claude-sonnet-4 --stream
+
+    # Using OpenAI directly:
+    python chat.py --llm-base-url https://api.openai.com/v1 --model gpt-4o
 """
 
 from __future__ import annotations
@@ -23,6 +26,7 @@ import argparse
 import json
 import os
 import sys
+from typing import Any
 
 try:
     from dotenv import load_dotenv
@@ -30,11 +34,9 @@ except ImportError:
     load_dotenv = None  # type: ignore[assignment, misc]
 
 try:
-    from google import genai
-    from google.genai import types
+    from openai import OpenAI
 except ImportError:
-    genai = None  # type: ignore[assignment]
-    types = None  # type: ignore[assignment]
+    OpenAI = None  # type: ignore[assignment, misc]
 
 from construct_labs_crm_env import CrmAgentEnv
 
@@ -42,8 +44,8 @@ from construct_labs_crm_env import CrmAgentEnv
 def _check_dependencies() -> None:
     """Check that optional dependencies are installed."""
     missing = []
-    if genai is None:
-        missing.append("google-genai")
+    if OpenAI is None:
+        missing.append("openai")
     if load_dotenv is None:
         missing.append("python-dotenv")
 
@@ -81,30 +83,6 @@ def print_separator(char: str = "-", width: int = 60) -> None:
     print(char * width)
 
 
-def convert_openai_tools_to_gemini(openai_tools: list[dict]) -> list[types.Tool]:
-    """Convert OpenAI-format tools to Gemini format."""
-    function_declarations = []
-
-    for tool in openai_tools:
-        if tool.get("type") != "function":
-            continue
-
-        func = tool["function"]
-        name = func["name"]
-        description = func.get("description", "")
-        parameters = func.get("parameters", {})
-
-        function_declarations.append(
-            types.FunctionDeclaration(
-                name=name,
-                description=description,
-                parameters=parameters if parameters else None,
-            )
-        )
-
-    return [types.Tool(function_declarations=function_declarations)]
-
-
 def format_tool_call_compact(tool_name: str, tool_args: dict) -> str:
     """Format a tool call in compact function-call style: func_name(arg1, arg2, ...)"""
     if not tool_args:
@@ -125,96 +103,130 @@ def format_tool_call_compact(tool_name: str, tool_args: dict) -> str:
 
 
 def _stream_response(
-    client: genai.Client,
+    client: OpenAI,
     model_name: str,
-    contents: list[types.Content],
-    config: types.GenerateContentConfig,
+    messages: list[dict[str, Any]],
+    tools: list[dict[str, Any]],
     print_output: bool = True,
-) -> tuple[list[str], list[types.FunctionCall], types.Content | None]:
+) -> tuple[str | None, list[dict[str, Any]], dict[str, Any] | None]:
     """
     Make a streaming call to the model, optionally printing tokens as they arrive.
 
     Returns:
-        Tuple of (text_parts, function_calls, final_content)
+        Tuple of (text_content, tool_calls, assistant_message)
     """
     text_parts: list[str] = []
-    function_calls: list[types.FunctionCall] = []
-    all_parts: list[types.Part] = []
+    tool_calls_by_index: dict[int, dict[str, Any]] = {}
 
-    for chunk in client.models.generate_content_stream(
+    stream = client.chat.completions.create(
         model=model_name,
-        contents=contents,
-        config=config,
-    ):
-        if not chunk.candidates:
-            continue
-
-        candidate = chunk.candidates[0]
+        messages=messages,
+        tools=tools,
+        temperature=0.7,
+        stream=True,
+    )
 
-        for part in candidate.content.parts:
-            if part.text:
-                if print_output:
-                    print(part.text, end="", flush=True)
-                text_parts.append(part.text)
-                all_parts.append(part)
+    for chunk in stream:
+        if not chunk.choices:
+            continue
 
-            if part.function_call:
-                function_calls.append(part.function_call)
-                all_parts.append(part)
+        delta = chunk.choices[0].delta
+
+        if delta.content:
+            if print_output:
+                print(delta.content, end="", flush=True)
+            text_parts.append(delta.content)
+
+        if delta.tool_calls:
+            for tc in delta.tool_calls:
+                idx = tc.index
+                if idx not in tool_calls_by_index:
+                    tool_calls_by_index[idx] = {
+                        "id": tc.id or "",
+                        "type": "function",
+                        "function": {"name": "", "arguments": ""},
+                    }
+                if tc.id:
+                    tool_calls_by_index[idx]["id"] = tc.id
+                if tc.function:
+                    if tc.function.name:
+                        tool_calls_by_index[idx]["function"]["name"] = tc.function.name
+                    if tc.function.arguments:
+                        tool_calls_by_index[idx]["function"][
+                            "arguments"
+                        ] += tc.function.arguments
 
     if print_output and text_parts:
         print()
 
-    if not all_parts:
-        return [], [], None
+    text_content = "".join(text_parts) if text_parts else None
+    tool_calls = [tool_calls_by_index[i] for i in sorted(tool_calls_by_index.keys())]
 
-    final_content = types.Content(role="model", parts=all_parts)
-    full_text = "".join(text_parts)
-    text_result = [full_text] if full_text else []
+    if not text_content and not tool_calls:
+        return None, [], None
 
-    return text_result, function_calls, final_content
+    assistant_message: dict[str, Any] = {"role": "assistant"}
+    if text_content:
+        assistant_message["content"] = text_content
+    if tool_calls:
+        assistant_message["tool_calls"] = tool_calls
+
+    return text_content, tool_calls, assistant_message
 
 
 def _non_stream_response(
-    client: genai.Client,
+    client: OpenAI,
     model_name: str,
-    contents: list[types.Content],
-    config: types.GenerateContentConfig,
-) -> tuple[list[str], list[types.FunctionCall], types.Content | None]:
+    messages: list[dict[str, Any]],
+    tools: list[dict[str, Any]],
+) -> tuple[str | None, list[dict[str, Any]], dict[str, Any] | None]:
     """Make a non-streaming call to the model."""
-    response = client.models.generate_content(
+    response = client.chat.completions.create(
         model=model_name,
-        contents=contents,
-        config=config,
+        messages=messages,
+        tools=tools,
+        temperature=0.7,
     )
 
-    if not response.candidates:
-        return [], [], None
-
-    candidate = response.candidates[0]
-    text_parts: list[str] = []
-    function_calls: list[types.FunctionCall] = []
+    if not response.choices:
+        return None, [], None
+
+    message = response.choices[0].message
+    text_content = message.content
+    tool_calls = []
+
+    if message.tool_calls:
+        for tc in message.tool_calls:
+            tool_calls.append(
+                {
+                    "id": tc.id,
+                    "type": "function",
+                    "function": {
+                        "name": tc.function.name,
+                        "arguments": tc.function.arguments,
+                    },
+                }
+            )
 
-    for part in candidate.content.parts:
-        if part.text:
-            text_parts.append(part.text)
-        if part.function_call:
-            function_calls.append(part.function_call)
+    assistant_message: dict[str, Any] = {"role": "assistant"}
+    if text_content:
+        assistant_message["content"] = text_content
+    if tool_calls:
+        assistant_message["tool_calls"] = tool_calls
 
-    return text_parts, function_calls, candidate.content
+    return text_content, tool_calls, assistant_message
 
 
 def run_agent_loop(
     env: CrmAgentEnv,
-    client: genai.Client,
+    client: OpenAI,
     model_name: str,
-    tools: list[types.Tool],
-    system_instruction: str,
-    contents: list[types.Content],
+    tools: list[dict[str, Any]],
+    messages: list[dict[str, Any]],
     max_iterations: int = 20,
     verbose: bool = False,
     stream: bool = False,
-) -> tuple[str | None, list[types.Content]]:
+) -> tuple[str | None, list[dict[str, Any]]]:
     """
     Run the agent loop until it calls submit_answer or reaches max iterations.
 
@@ -222,69 +234,64 @@ def run_agent_loop(
     until it's ready to submit a final answer.
 
     Returns:
-        Tuple of (final_answer or None, updated contents)
+        Tuple of (final_answer or None, updated messages)
     """
     iteration = 0
 
     while iteration < max_iterations:
         iteration += 1
 
-        config = types.GenerateContentConfig(
-            tools=tools,
-            system_instruction=system_instruction,
-            temperature=0.7,
-        )
-
         try:
             if stream:
-                text_parts, function_calls, final_content = _stream_response(
+                text_content, tool_calls, assistant_message = _stream_response(
                     client=client,
                     model_name=model_name,
-                    contents=contents,
-                    config=config,
+                    messages=messages,
+                    tools=tools,
                     print_output=False,
                 )
             else:
-                text_parts, function_calls, final_content = _non_stream_response(
+                text_content, tool_calls, assistant_message = _non_stream_response(
                     client=client,
                     model_name=model_name,
-                    contents=contents,
-                    config=config,
+                    messages=messages,
+                    tools=tools,
                 )
         except Exception as e:
             print_colored(f"API Error: {e}", "red")
-            return None, contents
+            return None, messages
 
-        if final_content is None:
+        if assistant_message is None:
             print_colored("Error: No response from model", "red")
-            return None, contents
+            return None, messages
 
-        contents.append(final_content)
+        messages.append(assistant_message)
 
-        if not function_calls:
-            if text_parts:
-                return "\n".join(text_parts), contents
-            return None, contents
+        if not tool_calls:
+            return text_content, messages
 
-        if text_parts:
+        if text_content:
             print_colored("\nThinking:", "dim")
-            print("\n".join(text_parts))
+            print(text_content)
 
-        function_response_parts = []
         final_answer = None
 
-        for func_call in function_calls:
-            tool_name = func_call.name
-            tool_args = dict(func_call.args) if func_call.args else {}
+        for tc in tool_calls:
+            tool_name = tc["function"]["name"]
+            try:
+                tool_args = json.loads(tc["function"]["arguments"])
+            except json.JSONDecodeError:
+                tool_args = {}
 
             if tool_name == "submit_answer":
                 final_answer = tool_args.get("answer", "")
                 print_colored("\n>>> Agent submitting answer", "cyan")
-                function_response_parts.append(
-                    types.Part.from_function_response(
-                        name=func_call.name,
-                        response={"result": "Answer submitted successfully."},
-                    )
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tc["id"],
+                        "content": "Answer submitted successfully.",
+                    }
                 )
                 continue
 
@@ -312,28 +319,27 @@ def run_agent_loop(
                     obs_text = f"Error executing action: {e}"
                     print_colored(f"  {obs_text}", "red")
 
-            function_response_parts.append(
-                types.Part.from_function_response(
-                    name=func_call.name,
-                    response={"result": obs_text},
-                )
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": obs_text,
+                }
             )
 
-        contents.append(types.Content(role="user", parts=function_response_parts))
-
         if final_answer is not None:
-            return final_answer, contents
+            return final_answer, messages
 
     print_colored(f"\nMax iterations ({max_iterations}) reached", "yellow")
-    return None, contents
+    return None, messages
 
 
 def run_chat(
     env: CrmAgentEnv,
-    client: genai.Client,
+    client: OpenAI,
     model_name: str,
-    tools: list[types.Tool],
-    system_instruction: str,
+    tools: list[dict[str, Any]],
+    system_prompt: str,
     initial_question: str | None = None,
     max_iterations: int = 20,
     verbose: bool = False,
@@ -353,7 +359,7 @@ def run_chat(
     env.reset()
     print_colored("Environment ready.\n", "green")
 
-    contents: list[types.Content] = []
+    messages: list[dict[str, Any]] = [{"role": "system", "content": system_prompt}]
 
     while True:
         if initial_question:
@@ -374,17 +380,14 @@ def run_chat(
 
         print_separator("=")
 
-        contents.append(
-            types.Content(role="user", parts=[types.Part.from_text(text=question)])
-        )
+        messages.append({"role": "user", "content": question})
 
-        answer, contents = run_agent_loop(
+        answer, messages = run_agent_loop(
             env=env,
             client=client,
             model_name=model_name,
             tools=tools,
-            system_instruction=system_instruction,
-            contents=contents,
+            messages=messages,
             max_iterations=max_iterations,
             verbose=verbose,
             stream=stream,
@@ -403,8 +406,6 @@ def main() -> None:
     """Main entry point for the chat CLI."""
     _check_dependencies()
 
-    # load_dotenv already called at module level if available
-
     parser = argparse.ArgumentParser(
         description="Interactive chat CLI for the CRM environment",
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -413,27 +414,36 @@ Examples:
     python chat.py
     python chat.py --stream
     python chat.py --question "How many companies are there?"
-    python chat.py --model gemini-2.0-flash --stream
+    python chat.py --model anthropic/claude-sonnet-4 --stream
+
+    # Using OpenAI directly:
+    python chat.py --llm-base-url https://api.openai.com/v1 --model gpt-4o
         """,
     )
 
     parser.add_argument(
-        "--base-url",
+        "--crm-base-url",
         type=str,
         default="https://env.crm.construct-labs.com",
         help="Base URL for the CRM environment (default: https://env.crm.construct-labs.com)",
     )
+    parser.add_argument(
+        "--llm-base-url",
+        type=str,
+        default="https://openrouter.ai/api/v1",
+        help="Base URL for OpenAI-compatible API (default: OpenRouter)",
+    )
     parser.add_argument(
         "--model",
         type=str,
-        default="gemini-2.0-flash",
-        help="Gemini model to use (default: gemini-2.0-flash)",
+        default="anthropic/claude-sonnet-4.5",
+        help="Model to use (default: anthropic/claude-sonnet-4.5)",
     )
     parser.add_argument(
         "--api-key",
         type=str,
         default=None,
-        help="Google API key (default: uses GOOGLE_API_KEY env var)",
+        help="API key (default: uses OPENAI_API_KEY env var)",
     )
     parser.add_argument(
         "--question",
@@ -460,23 +470,21 @@ Examples:
 
     args = parser.parse_args()
 
-    api_key = args.api_key or os.getenv("GOOGLE_API_KEY")
+    api_key = args.api_key or os.getenv("OPENAI_API_KEY")
     if not api_key:
-        print_colored("Error: No Google API key provided.", "red")
-        print_colored("Set GOOGLE_API_KEY in .env file or use --api-key", "dim")
+        print_colored("Error: No API key provided.", "red")
+        print_colored("Set OPENAI_API_KEY in .env file or use --api-key", "dim")
         sys.exit(1)
 
-    client = genai.Client(api_key=api_key)
+    client = OpenAI(api_key=api_key, base_url=args.llm_base_url)
 
-    print_colored(f"Connecting to CRM environment at {args.base_url}...", "dim")
+    print_colored(f"Connecting to CRM environment at {args.crm_base_url}...", "dim")
     try:
-        env = CrmAgentEnv(base_url=args.base_url)
+        env = CrmAgentEnv(base_url=args.crm_base_url)
     except Exception as e:
         print_colored(f"Error connecting to environment: {e}", "red")
         sys.exit(1)
 
-    gemini_tools = convert_openai_tools_to_gemini(env.tools)
-
     system_prompt = """You are a helpful assistant with access to CRM tools.
 
 Use the provided tools to help the user with their requests. You can make multiple tool calls to complete a task.
@@ -489,8 +497,8 @@ When you have gathered enough information or completed the task, call submit_ans
                 env=env,
                 client=client,
                 model_name=args.model,
-                tools=gemini_tools,
-                system_instruction=system_prompt,
+                tools=env.tools,
+                system_prompt=system_prompt,
                 initial_question=args.question,
                 max_iterations=args.max_iterations,
                 verbose=args.verbose,