corethink 1.0.2__tar.gz → 1.0.4__tar.gz

{corethink-1.0.2 → corethink-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corethink
-Version: 1.0.2
+Version: 1.0.4
 Summary: The CoreThink Workbench from your terminal: environments, training, endpoints and more.
 Author-email: CoreThink <support@corethink.ai>
 License-Expression: MIT

{corethink-1.0.2 → corethink-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "corethink"
-version = "1.0.2"
+version = "1.0.4"
 description = "The CoreThink Workbench from your terminal: environments, training, endpoints and more."
 readme = "README.md"
 requires-python = ">=3.10"

{corethink-1.0.2 → corethink-1.0.4}/src/corethink/_version.py

@@ -1,3 +1,3 @@
 """The version of the `corethink` package (read by the build and by `corethink --version`)."""
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"

{corethink-1.0.2 → corethink-1.0.4}/src/corethink/commands/endpoint.py

@@ -291,7 +291,7 @@ def _canary(percent: float | None, minutes: int | None) -> dict[str, Any]:
 def list_() -> None:
     """List every environment's endpoint and what staging and production serve.
 
-    One row per environment in your workspace: its name and ID, the version on production and on staging (a dash when nothing is released there), and the model name to call. Below the table: how many endpoints serve a program, and the gateway's base URL. Use it to find an environment's ID and model name.
+    One row per environment in your workspace: its name and ID, the version on production and on staging (a dash when nothing is released there), and the model name to call. Below the table: how many endpoints serve a program, and the gateway's base URL. "unavailable" means that endpoint could not be read just then; the reason is printed below, and trying again usually works. Use it to find an environment's ID and model name.
 
     With `--json`: `gateway` (the base URL) and `endpoints`, each with `id`, `name`, `program`, `production`, `staging` and `error`. Next: `corethink endpoint show ENV`.
 
@@ -354,6 +354,11 @@ def list_() -> None:
         if rows:
             live = sum(1 for r in rows if r["production"] or r["staging"])
             ui.info(f"{live} of {len(rows)} serving a program · base URL {base} · model <program>@<alias>")
+        failed = [r for r in rows if r["error"] and not r["staging"]]
+        if failed:
+            ui.warn(
+                f"Could not read {len(failed)} endpoint{'' if len(failed) == 1 else 's'} just now ({failed[0]['error']}). Try again."
+            )
 
     ui.emit({"gateway": base, "endpoints": rows}, human)
 
@@ -937,7 +942,7 @@ def keys_usage(
 ) -> None:
     """Show requests, tokens and cost per day for your endpoint keys.
 
-    Every key of the workspace by default; one key (give its ID or name) or one environment's keys (`--env`). It shows the last 30 days, or fewer with `--days`, and the totals below.
+    Every key of the workspace by default; one key (give its ID or name) or one environment's keys (`--env`). The table lists the days with requests in the last 30 days (or fewer with `--days`), and the totals below.
 
     With `--json`: `daily` (each day's `at`, `requests`, `tokens` and `cost`) and `total`.
 
@@ -969,14 +974,14 @@ def keys_usage(
 
     def human() -> None:
         ui.table(
-            rows,
+            [r for r in rows if int(r.get("requests") or 0) > 0],
             [
                 ("Day", lambda r: str(r.get("at") or "")[:10]),
                 ("Requests", lambda r: f"{int(r.get('requests') or 0):,}"),
                 ("Tokens", lambda r: f"{int(r.get('tokens') or 0):,}"),
                 ("Cost", lambda r: ui.usd(r.get("cost"), 4)),
             ],
-            empty="No usage yet.",
+            empty=f"No requests in the last {days} days.",
         )
         ui.info(
             f"{scope}, last {days} days: {total['requests']:,} requests · {total['tokens']:,} tokens · {ui.usd(total['cost'])}"
@@ -1057,7 +1062,7 @@ def call(
 ) -> None:
     """Send one chat completion to an endpoint and print the answer.
 
-    Sends your message (after `--system` and the earlier turns in `--messages`, with the tools from `--tools`) to the program on staging (the default), on production (`--alias production`) or on a fixed version, and prints its answer, any tool calls it asks for, and which version answered. The program asks for tool calls the way any OpenAI model does; your code runs them. Use it to try a program before you wire it into your app.
+    Sends your message (after `--system` and the earlier turns in `--messages`, with the tools from `--tools`) to the program on staging (the default), on production (`--alias production`) or on a fixed version, and prints its answer, any tool calls it asks for, and which version answered. The program asks for tool calls the way any OpenAI model does; your code runs them. If the environment has tools, pass them (`--tools usecase.json`): without them the program answers without your data, and the command warns you. Use it to try a program before you wire it into your app.
 
     Calling needs only an endpoint key, from `CORETHINK_API_KEY` (make one with `corethink endpoint keys create ENV`). Give the program as `<workspace>/<environment>`, optionally with `@alias`, to skip the Workbench lookup (no sign-in needed). With `--json`: the whole response, including which program version answered (`corethink_program`).
 
@@ -1095,12 +1100,14 @@ def call(
         ui.error('Give a message: corethink endpoint call ENV "your message".')
         raise typer.Exit(2)
 
-    program, given_alias, _env = _target(env)
+    program, given_alias, found = _target(env)
     model = f"{program}@{given_alias or alias}"
     base = _gateway_base(gateway_url)
     body: dict[str, Any] = {"model": model, "messages": chat}
     if tools_file:
         body["tools"] = _tools_from(tools_file)
+    elif found and found.get("tools"):
+        ui.warn(_tools_hint(found, "Without them it answers without your data: pass them with --tools usecase.json"))
     try:
         with (
             httpx.Client(
@@ -1155,6 +1162,14 @@ def call(
     ui.emit(answer, human)
 
 
+def _tools_hint(env: dict[str, Any], then: str) -> str:
+    names = ", ".join(env.get("tools") or [])
+    return (
+        f"This program works with tools ({names}). {then} "
+        f"(`corethink env cat {env.get('id')} usecase.json > usecase.json` has them)."
+    )
+
+
 def _snippets(base: str, model: str) -> dict[str, str]:
     """The console's examples (Account.tsx apiSnippets), for this endpoint."""
     curl = (
@@ -1194,7 +1209,9 @@ def snippet(
 
     A curl command (the default) or a Python script with the OpenAI client (`--lang python`), with this endpoint's base URL and model name filled in. Nothing is called. Set `CORETHINK_API_KEY` to a key of this endpoint before you run it. Streaming is not supported yet.
 
-    With `--json`: `model`, `base_url`, and both examples (`curl` and `python`).
+    If the environment has tools, it also names them and where to get their definitions (usecase.json's `tools`).
+
+    With `--json`: `model`, `base_url`, both examples (`curl` and `python`), and `tools` (the environment's tool names).
 
     Examples:
       corethink endpoint snippet refunds --lang python > call.py
@@ -1204,11 +1221,11 @@ def snippet(
     if lang not in ("curl", "python"):
         ui.error("--lang is curl or python.")
         raise typer.Exit(2)
-    program, given_alias, _env = _target(env)
+    program, given_alias, found = _target(env)
     model = f"{program}@{given_alias or alias}"
     base = _gateway_base(gateway_url)
     snippets = _snippets(base, model)
-    data = {"model": model, "base_url": base, **snippets}
+    data = {"model": model, "base_url": base, **snippets, "tools": (found or {}).get("tools") or []}
 
     def human() -> None:
         sys.stdout.write(snippets[lang] + "\n")
@@ -1216,6 +1233,8 @@ def snippet(
         ui.info(
             "Set CORETHINK_API_KEY to a key of this endpoint (`corethink endpoint keys create`). Streaming is not supported yet."
         )
+        if found and found.get("tools"):
+            ui.info(_tools_hint(found, "Send them as `tools`; your code runs each call and sends back its result"))
 
     ui.emit(data, human)
 

{corethink-1.0.2 → corethink-1.0.4}/src/corethink/commands/train.py

@@ -1021,6 +1021,12 @@ def credit_available() -> tuple[float | None, dict[str, Any] | None]:
     return (float(available) if available is not None else None), me.get("welcomeCredit")
 
 
+def likely_cost(estimate: dict[str, Any] | None) -> float | None:
+    """What a run is likely to cost: from past runs, else the first-run estimate (a Hub copy's: what its Hub program cost)."""
+    estimate = estimate or {}
+    return estimate.get("costUsd") or (estimate.get("firstRun") or {}).get("typicalUsd")
+
+
 def default_budget(estimate_usd: Any, available: float | None, most: float | None, least: float = 1) -> float:
     """About 1.5 times the estimate (whole dollars), else $20; never above the most or the credit (Training.tsx)."""
     wanted = math.ceil(float(estimate_usd) * 1.5) if estimate_usd and float(estimate_usd) > 0 else FIRST_RUN_BUDGET
@@ -1075,6 +1081,8 @@ def estimate_lines(estimate: dict[str, Any] | None, budget: float | None = None)
             text += " The limit is lower; it may stop early."
         elif estimate.get("costUsd") is None and first and (first.get("lowUsd") or 0) > budget:
             text += " The limit is below the low end; it will likely stop early."
+        elif estimate.get("costUsd") is None and first and (first.get("typicalUsd") or 0) > budget:
+            text += " The limit is below the likely cost; it may stop early."
     if estimate.get("waiting"):
         text += f" {plural(estimate['waiting'], 'run')} waiting ahead."
     lines = [text]
@@ -1206,6 +1214,16 @@ def _estimate(plan: Plan) -> dict[str, Any] | None:
         return None
 
 
+def eval_tasks(plan: Plan) -> int:
+    """Tasks in the final check: at most those held out from training."""
+    usecase = plan.usecase or {}
+    if usecase.get("split"):
+        return int(usecase["split"].get("test") or 0)
+    if usecase.get("scenarios"):
+        return min(plan.check_tasks, withheld_tasks(int(usecase["scenarios"]), plan.share))
+    return plan.check_tasks
+
+
 def _limits_panel(plan: Plan, budget: float, available: float | None, estimate: dict[str, Any] | None) -> None:
     """The console's "Limits for this run" box, on stderr (stdout is for the run itself)."""
     usecase = plan.usecase
@@ -1227,7 +1245,7 @@ def _limits_panel(plan: Plan, budget: float, available: float | None, estimate:
         ("Hyperparameters", "Advanced" if advanced else "Automatic"),
         ("Spending", f"max {ui.usd(budget, 0 if float(budget).is_integer() else 2)}"),
         ("Trains on", trains),
-        ("Eval set tasks", str(split.get("test") if split else plan.check_tasks)),
+        ("Eval set tasks", str(eval_tasks(plan))),
     ]
     if plan.method:
         rows.append(("Training method", METHOD_LABEL.get(plan.method, plan.method)))
@@ -1350,7 +1368,7 @@ def start(
     least, most = run_limits()
     available, welcome = credit_available()
     estimate = _estimate(plan)
-    budget = limit if limit is not None else default_budget((estimate or {}).get("costUsd"), available, most, least)
+    budget = limit if limit is not None else default_budget(likely_cost(estimate), available, most, least)
     problem = budget_problem(budget, least, most, available, welcome)
     if problem:
         raise fail(problem)
@@ -1546,7 +1564,7 @@ def estimate(
     def human() -> None:
         least, most = run_limits()
         available, _ = credit_available()
-        budget = default_budget(answer.get("costUsd"), available, most, least)
+        budget = default_budget(likely_cost(answer), available, most, least)
         for line in estimate_lines(answer):
             ui.out.print(line, style="dim" if line.startswith("  ") else None)
         ui.out.print(

{corethink-1.0.2 → corethink-1.0.4}/src/corethink.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: corethink
-Version: 1.0.2
+Version: 1.0.4
 Summary: The CoreThink Workbench from your terminal: environments, training, endpoints and more.
 Author-email: CoreThink <support@corethink.ai>
 License-Expression: MIT

{corethink-1.0.2 → corethink-1.0.4}/tests/test_endpoint.py

@@ -5,7 +5,7 @@ import pytest
 ENVS = [
     {"id": "refunds-22982c", "org": "acme", "name": "Refunds"},
     {"id": "refunds-old-1a2b3c", "org": "acme", "name": "Refunds (old)"},
-    {"id": "triage-77aa00", "org": "acme", "name": "Triage"},
+    {"id": "triage-77aa00", "org": "acme", "name": "Triage", "tools": ["lookup_order", "refund"]},
 ]
 STAGING_HASH = "b" * 64
 PROD_HASH = "a" * 64
@@ -143,6 +143,7 @@ def test_list(served, run):
     assert table.code == 0, table.err
     assert "v-aaaaaaaaaaaa" in table.out and "acme/refunds-22982c@production" in table.out
     assert "unavailable" in table.out
+    assert "Could not read 1 endpoint just now (unavailable)" in table.err
     assert "1 of 3 serving" in table.err and "https://gateway.test/v1" in table.err
     data = run("--json", "endpoint", "list").json()
     assert data["gateway"] == "https://gateway.test/v1"
@@ -416,6 +417,14 @@ def test_keys_usage(served, run):
     assert served.called("GET", "/api/v1/harnesses/keys/usage")[-1].params == {"environment": "triage-77aa00"}
     one = run("endpoint", "keys", "usage", "web-app")
     assert one.code == 0 and "2026-10-03" in one.out and "web-app, last 30 days: 6 requests" in one.err
+    # the table lists the days with requests (JSON keeps every day)
+    quiet = [{**day, "requests": 0, "tokens": 0, "cost": 0} for day in daily[:-1]] + daily[-1:]
+    served.on("GET", "/api/v1/harnesses/keys/usage", {"daily": quiet})
+    table = run("endpoint", "keys", "usage")
+    assert "2026-10-30" in table.out and "2026-10-29" not in table.out
+    assert len(run("--json", "endpoint", "keys", "usage").json()["daily"]) == 30
+    served.on("GET", "/api/v1/harnesses/keys/usage", {"daily": [{**day, "requests": 0} for day in quiet[:-1]]})
+    assert "No requests in the last 30 days." in run("endpoint", "keys", "usage").err
     served.on("GET", "/api/v1/harnesses/keys/usage", {"daily": None})
     assert "cannot be read" in run("endpoint", "keys", "usage").err
 
@@ -460,6 +469,20 @@ def test_call_with_the_env_key(served, run, monkeypatch):
     as_json = run("--json", "endpoint", "call", "refunds", "Hi", "--alias", "production").json()
     assert as_json["corethink_program"]["version"] == "harness-bbbbbbbbbbbb"
     assert served.called("POST", "/v1/chat/completions")[-1].body["model"] == "acme/refunds-22982c@production"
+    assert "works with tools" not in result.err
+
+
+def test_call_warns_when_the_program_needs_tools_and_none_are_given(served, run, tmp_path, monkeypatch):
+    monkeypatch.setenv("CORETHINK_API_KEY", "ctk_endpointkey")
+    monkeypatch.setenv("CORETHINK_GATEWAY_URL", "https://gateway.test/v1")
+    served.on("POST", "/v1/chat/completions", ANSWER)
+    bare = run("endpoint", "call", "triage", "Refund order 7")
+    assert bare.code == 0, bare.err
+    assert "This program works with tools (lookup_order, refund)" in bare.err
+    assert "corethink env cat triage-77aa00 usecase.json" in bare.err
+    tools = tmp_path / "tools.json"
+    tools.write_text(json.dumps([{"type": "function", "function": {"name": "lookup_order"}}]))
+    assert "works with tools" not in run("endpoint", "call", "triage", "Hi", "--tools", str(tools)).err
 
 
 def test_call_a_program_directly_with_tools_from_usecase_json(wb, run, tmp_path, monkeypatch):
@@ -606,11 +629,17 @@ def test_snippets(served, run):
         "https://gateway.test/v1",
     )
     assert 'base_url="https://gateway.test/v1"' in python.out and 'model="acme/refunds-22982c@production"' in python.out
+    assert "works with tools" not in curl.err
     data = run("--json", "endpoint", "snippet", "acme/x@production").json()
     assert data["model"] == "acme/x@production" and set(data) == {
         "model",
         "base_url",
         "curl",
         "python",
+        "tools",
     }
+    assert data["tools"] == []
+    tooled = run("endpoint", "snippet", "triage")
+    assert "This program works with tools (lookup_order, refund). Send them as `tools`" in tooled.err
+    assert run("--json", "endpoint", "snippet", "triage").json()["tools"] == ["lookup_order", "refund"]
     assert run("endpoint", "snippet", "refunds", "--lang", "go").code == 2

{corethink-1.0.2 → corethink-1.0.4}/tests/test_train.py

@@ -250,6 +250,28 @@ def test_start_default_limit_follows_the_estimate(form, run):
     assert result.json()["job_id"] == RUN
 
 
+def test_start_default_limit_follows_a_first_run_estimate_within_the_credit(form, run):
+    """No past run: the first-run estimate sets the limit (it was $20 whatever the estimate: MDM's Hub program cost $57)."""
+    first = {"typicalUsd": 12, "lowUsd": 8.4, "highUsd": 18, "drivers": [], "assumptions": []}
+    form.on(
+        "GET",
+        f"{JOBS}:estimate",
+        {"domain": "custom", "costUsd": None, "minutes": None, "basedOn": 0, "firstRun": first},
+    )
+    result = run("--json", "train", "start", "Payroll", "--yes")
+    assert result.code == 0, result.err
+    assert form.called("POST", JOBS)[-1].body["budgetUsd"] == 18
+    form.on(
+        "GET",
+        f"{JOBS}:estimate",
+        {"domain": "custom", "costUsd": None, "firstRun": {**first, "typicalUsd": 57.3, "lowUsd": 60}},
+    )
+    dear = run("train", "start", "Payroll", "--yes")
+    assert dear.code == 0, dear.err
+    assert form.called("POST", JOBS)[-1].body["budgetUsd"] == 50  # the credit available
+    assert "will likely stop early" in " ".join(dear.err.split())
+
+
 def test_start_advanced_settings_payload_with_providers_chosen(form, run):
     providers = {
         "qwen/qwen3.7-flash": {
@@ -957,3 +979,25 @@ def test_start_from_an_earlier_run_repeats_its_environment_and_settings(form, ru
 
 def test_start_needs_an_environment_or_a_run(form, run):
     assert run("train", "start", "--yes").code == 2
+
+
+def test_a_first_runs_limit_below_its_likely_cost_is_flagged():
+    from corethink.commands.train import estimate_lines
+
+    first = {"typicalUsd": 57.3, "lowUsd": 40.1, "highUsd": 85.9, "drivers": [], "assumptions": []}
+    estimate = {"costUsd": None, "minutes": None, "firstRun": first}
+    assert "may stop early" not in estimate_lines(estimate, 86)[0]
+    assert estimate_lines(estimate, 45)[0].endswith("The limit is below the likely cost; it may stop early.")
+    assert estimate_lines(estimate, 30)[0].endswith("The limit is below the low end; it will likely stop early.")
+
+
+def test_the_eval_set_is_at_most_the_tasks_held_out():
+    from corethink.commands.train import Plan, eval_tasks
+
+    made = Plan.__new__(Plan)
+    made.usecase, made.share, made.check_tasks = {"scenarios": 80}, 0.6, 40
+    assert eval_tasks(made) == 32  # 80 tasks, 48 to train on: 32 held out, not the 40 asked for
+    made.usecase = {"scenarios": 200}
+    assert eval_tasks(made) == 40
+    made.usecase = {"scenarios": 200, "split": {"train": 150, "test": 50}}
+    assert eval_tasks(made) == 50