Extract and summarise bounds are each agent's own limits, set on its form
agents.limits holds extract_top, extract_min, summarise_top and summarise_min; the scope query reads them per ranked row, and a row saved before this behaves like a fresh agent. The four global config keys go. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
1 parent
e602eb3388
commit
cebe62ddc9
20 files changed
+229
-147
No files matched your search
+8
-17
@@ -22,7 +22,7 @@ from typing import Any, Literal
|
||||
import yaml
|
||||
from pydantic import Field, ValidationError, model_validator
|
||||
|
||||
from app.models import Gate, Weights
|
||||
from app.models import Gate, Limits, Weights
|
||||
from auth import AuthConfig
|
||||
from desk.config import AgentConfig, ModelTaskConfig, Section, WorkersConfig
|
||||
|
||||
@@ -43,37 +43,27 @@ class ExtractConfig(ModelTaskConfig):
|
||||
"""Turning a posting's title and text into the gate columns. See
|
||||
app/jobs/extract.py. Off by default, so nobody is billed by surprise:
|
||||
on the API backend every batch is a paid call. On, it reads only the
|
||||
best `per_agent` roles of each enabled agent that score at least
|
||||
`min_score`, so the cost follows the ranking rather than the boards."""
|
||||
best roles of each enabled agent, as deep and as low as that agent's
|
||||
own `limits` say, so the cost follows the ranking rather than the
|
||||
boards."""
|
||||
|
||||
enabled: bool = False
|
||||
model: str = "claude-haiku-4-5-20251001"
|
||||
batch_size: int = Field(20, ge=1)
|
||||
#: How deep into each enabled agent's ranking extract reads: the backstop.
|
||||
per_agent: int = Field(500, ge=0)
|
||||
#: Below this score a role is not read, however few are above it. Loose,
|
||||
#: since a fresh role with the worst fit scores about 0.27 on the default
|
||||
#: weights and a good one 0.6 or more.
|
||||
min_score: float = Field(0.3, ge=0, le=1)
|
||||
|
||||
|
||||
class SummariseConfig(ModelTaskConfig):
|
||||
"""About 60 words on a role, for the list and the read page. See
|
||||
app/jobs/summarise.py. Off by default like extract; on, a pull summarises
|
||||
only the best `per_agent` of each enabled agent, so the cost is bounded
|
||||
whatever the backlog. The read page's Summarise button asks for one role
|
||||
whether this is on or not."""
|
||||
only the best of each enabled agent, as deep and as low as that agent's
|
||||
own `limits` say, so the cost is bounded whatever the backlog. The read
|
||||
page's Summarise button asks for one role whether this is on or not."""
|
||||
|
||||
enabled: bool = False
|
||||
model: str = "claude-haiku-4-5-20251001"
|
||||
#: A description is capped at 8000 characters per role, so ten is about
|
||||
#: 20k tokens of input per call.
|
||||
batch_size: int = Field(10, ge=1)
|
||||
#: How deep into each enabled agent's ranking a pull summarises.
|
||||
per_agent: int = Field(30, ge=0)
|
||||
#: Below this score a role is not summarised. Stricter than extract's,
|
||||
#: since a summary is the expensive answer.
|
||||
min_score: float = Field(0.5, ge=0, le=1)
|
||||
|
||||
|
||||
class EmbedConfig(Section):
|
||||
@@ -96,6 +86,7 @@ class AgentSeed(Section):
|
||||
intent: str = ""
|
||||
gates: list[Gate] = Field(default_factory=list)
|
||||
weights: Weights = Field(default_factory=Weights)
|
||||
limits: Limits = Field(default_factory=Limits)
|
||||
enabled: bool = True
|
||||
|
||||
|
||||
|
||||
+3
-4
@@ -12,10 +12,9 @@ nothing: `extract.enabled: false`, or an `on_ingest` this pull does not
|
||||
satisfy, is an extract stage with no batches whose final job moves straight
|
||||
on. The free stages go first: embed and score cost no tokens, and the score
|
||||
they produce is what bounds the two that do. Extract reads only the best
|
||||
`extract.per_agent` roles of each enabled agent, not below
|
||||
`extract.min_score`; the second score then applies the gates to the columns
|
||||
it filled. Summarise runs last, on the best `summarise.per_agent` roles not
|
||||
below `summarise.min_score`.
|
||||
roles of each enabled agent, as deep and as low as that agent's own `limits`
|
||||
say; the second score then applies the gates to the columns it filled.
|
||||
Summarise runs last, on the best roles by the same agent's summarise limits.
|
||||
|
||||
A batch that failed, or a stage somebody killed, does not stop the chain: the
|
||||
work comes round on the next pull, and a rescore of what did arrive is worth
|
||||
|
||||
+7
-10
@@ -8,9 +8,10 @@ refused batch, and failing with a notice when no model is reachable are
|
||||
`desk.modeltask`'s.
|
||||
|
||||
A role is waiting while it is open, has never been answered (`extracted_at IS
|
||||
NULL`), has not been given up on, and is in the best `extract.per_agent` of an
|
||||
enabled agent's ungated scores at `extract.min_score` or more. That bound is
|
||||
what keeps the cost proportional to the rankings rather than to the boards:
|
||||
NULL`), has not been given up on, and is in the best of an enabled agent's
|
||||
ungated scores as deep and as low as that agent's own `limits` say
|
||||
(`extract_top`, `extract_min`). That bound is what keeps the cost
|
||||
proportional to the rankings rather than to the boards:
|
||||
the pull scores every role for free first, then reads the few hundred that
|
||||
rank, and scores again so the gates see what was filled. A batch built for
|
||||
named uids finishes what it was dealt whatever their rank. The answer only
|
||||
@@ -133,8 +134,7 @@ def _item(role: Role) -> dict[str, Any]:
|
||||
def build_batch(config: Config, store: Store, limit: int = 20,
|
||||
uids: Sequence[str] | None = None) -> dict[str, Any]:
|
||||
return {"instructions": SYSTEM,
|
||||
"roles": [_item(r) for r in store.extract_waiting(
|
||||
limit, config.extract.per_agent, config.extract.min_score, uids)]}
|
||||
"roles": [_item(r) for r in store.extract_waiting(limit, uids)]}
|
||||
|
||||
|
||||
# -------------------------------------------------------------------- answer
|
||||
@@ -205,11 +205,8 @@ TASK: ModelTask[ExtractResult] = ModelTask(
|
||||
kind="extract", label="Reading postings for gate fields",
|
||||
verb="extracting", noun="fields", idle="nothing to extract", items="roles",
|
||||
settings=lambda config: config.extract,
|
||||
pending=lambda config, store: store.extract_pending(
|
||||
config.extract.per_agent, config.extract.min_score),
|
||||
waiting=lambda config, store, limit: [
|
||||
r.uid for r in store.extract_waiting(
|
||||
limit, config.extract.per_agent, config.extract.min_score)],
|
||||
pending=lambda config, store: store.extract_pending(),
|
||||
waiting=lambda config, store, limit: [r.uid for r in store.extract_waiting(limit)],
|
||||
build_batch=build_batch,
|
||||
system=lambda store: SYSTEM,
|
||||
schema=SCHEMA,
|
||||
|
||||
+1
-1
@@ -276,7 +276,7 @@ def seed_agents(config: Config, store: Store) -> list[str]:
|
||||
for seed in config.agents:
|
||||
try:
|
||||
store.save_agent(seed.name, seed.intent, seed.gates, seed.weights,
|
||||
seed.enabled)
|
||||
seed.enabled, limits=seed.limits)
|
||||
except ValueError as exc:
|
||||
log.warning("agents: %s", exc)
|
||||
continue
|
||||
|
||||
@@ -6,9 +6,10 @@ what the model is told, the schema it answers in, what to do with the
|
||||
answer), and running it is `desk.modeltask`'s.
|
||||
|
||||
A role is waiting while it has no summary, has some text, and is in the top
|
||||
`summarise.per_agent` of an enabled agent's ungated scores at
|
||||
`summarise.min_score` or more. That bound is what keeps the cost flat: a pull
|
||||
summarises the roles somebody will look at, not the 30k that are open. A batch built for named uids (the read page's Summarise
|
||||
of an enabled agent's ungated scores as deep and as low as that agent's own
|
||||
`limits` say (`summarise_top`, `summarise_min`). That bound is what keeps the
|
||||
cost flat: a pull summarises the roles somebody will look at, not the 30k
|
||||
that are open. A batch built for named uids (the read page's Summarise
|
||||
button) takes those roles whatever their rank. See `Store.summarise_waiting`.
|
||||
|
||||
The text is `article_text` when the posting page was fetched, else
|
||||
@@ -121,8 +122,7 @@ def _item(role: Role) -> dict[str, Any]:
|
||||
|
||||
def _waiting(config: Config, store: Store, limit: int,
|
||||
uids: Sequence[str] | None = None) -> list[Role]:
|
||||
return store.summarise_waiting(limit, config.summarise.per_agent, uids,
|
||||
min_score=config.summarise.min_score)
|
||||
return store.summarise_waiting(limit, uids)
|
||||
|
||||
|
||||
def build_batch(config: Config, store: Store, limit: int = 10,
|
||||
@@ -166,8 +166,7 @@ TASK: ModelTask[SummariseResult] = ModelTask(
|
||||
verb="summarising", noun="summaries", idle="nothing to summarise",
|
||||
items="summaries",
|
||||
settings=lambda config: config.summarise,
|
||||
pending=lambda config, store: store.summarise_pending(
|
||||
config.summarise.per_agent, config.summarise.min_score),
|
||||
pending=lambda config, store: store.summarise_pending(),
|
||||
waiting=lambda config, store, limit: [r.uid for r in _waiting(config, store, limit)],
|
||||
build_batch=build_batch,
|
||||
system=lambda store: SYSTEM,
|
||||
|
||||
+18
-2
@@ -388,15 +388,31 @@ class Weights(Model):
|
||||
taste: float = Field(0.2, ge=0)
|
||||
|
||||
|
||||
class Limits(Model):
|
||||
"""How far down an agent's ranking the two model stages read. Each pair
|
||||
is a top N, the backstop, and a minimum score, the real stop: a role
|
||||
is read when it is among the agent's best `extract_top` ungated scores
|
||||
and not below `extract_min`, and summarised likewise. A fresh role with
|
||||
the worst fit scores about 0.27 on the default weights, a good one 0.6
|
||||
or more, so extract's floor is loose and summarise's, the long answer,
|
||||
stricter."""
|
||||
|
||||
extract_top: int = Field(500, ge=0)
|
||||
extract_min: float = Field(0.3, ge=0, le=1)
|
||||
summarise_top: int = Field(30, ge=0)
|
||||
summarise_min: float = Field(0.5, ge=0, le=1)
|
||||
|
||||
|
||||
class Agent(Model):
|
||||
"""A row of `agents`: a named search with its own intent, gates and
|
||||
weights. The cached intent vector is a column this does not declare."""
|
||||
"""A row of `agents`: a named search with its own intent, gates, weights
|
||||
and limits. The cached intent vector is a column this does not declare."""
|
||||
|
||||
id: int
|
||||
name: str
|
||||
intent: str = ""
|
||||
gates: Annotated[list[Gate], BeforeValidator(lambda v: _json(v, "[]"))] = []
|
||||
weights: Annotated[Weights, BeforeValidator(lambda v: _json(v, "{}"))] = Weights()
|
||||
limits: Annotated[Limits, BeforeValidator(lambda v: _json(v, "{}"))] = Limits()
|
||||
enabled: bool = True
|
||||
created_at: str
|
||||
|
||||
|
||||
@@ -20,6 +20,10 @@
|
||||
const $ = (sel, root = document) => root.querySelector(sel);
|
||||
|
||||
const DEFAULT_WEIGHTS = { fit: 0.6, recency: 0.2, affinity: 0.2, taste: 0.2 };
|
||||
// What the model reads after a pull, per agent: the best `extract_top`
|
||||
// roles scoring at least `extract_min` get their gate columns filled, the
|
||||
// best `summarise_top` at `summarise_min` or more a summary.
|
||||
const DEFAULT_LIMITS = { extract_top: 500, extract_min: 0.3, summarise_top: 30, summarise_min: 0.5 };
|
||||
const NEW = "new";
|
||||
|
||||
/** @type {object[]} every agent, as the server lists them */
|
||||
@@ -108,6 +112,11 @@
|
||||
return `fit ${w.fit} · newness ${w.recency} · companies ${w.affinity} · liked ${w.taste}${gates}`;
|
||||
}
|
||||
|
||||
function limitsLine(row) {
|
||||
const l = Object.assign({}, DEFAULT_LIMITS, row.limits);
|
||||
return `reads ${l.extract_top} at ${l.extract_min} · summarises ${l.summarise_top} at ${l.summarise_min}`;
|
||||
}
|
||||
|
||||
function card(row, fallback) {
|
||||
const div = el("article", "agent-card");
|
||||
if (!row.enabled) div.dataset.off = "true";
|
||||
@@ -127,6 +136,7 @@
|
||||
? el("p", "agent-intent", intent)
|
||||
: el("p", "agent-intent empty", "Nothing described yet, so fit has nothing to measure against. Edit says what this agent looks for."));
|
||||
div.appendChild(el("p", "agent-weights", weightsLine(row)));
|
||||
div.appendChild(el("p", "agent-limits", limitsLine(row)));
|
||||
|
||||
const actions = el("div", "agent-card-actions");
|
||||
const edit = el("button", "secondary", "Edit");
|
||||
@@ -151,6 +161,7 @@
|
||||
const div = el("article", "agent-card editing");
|
||||
const f = $("#agent-form-template").content.querySelector("form").cloneNode(true);
|
||||
const weights = Object.assign({}, DEFAULT_WEIGHTS, row ? row.weights : {});
|
||||
const limits = Object.assign({}, DEFAULT_LIMITS, row ? row.limits : {});
|
||||
$("#agent-form-title", f).textContent = row ? `Edit ${row.name}` : "New agent";
|
||||
$("#a-name", f).value = row ? row.name : "";
|
||||
$("#a-intent", f).value = row ? row.intent : "";
|
||||
@@ -159,6 +170,10 @@
|
||||
$("#a-recency", f).value = weights.recency;
|
||||
$("#a-affinity", f).value = weights.affinity;
|
||||
$("#a-taste", f).value = weights.taste;
|
||||
$("#a-extract-top", f).value = limits.extract_top;
|
||||
$("#a-extract-min", f).value = limits.extract_min;
|
||||
$("#a-summarise-top", f).value = limits.summarise_top;
|
||||
$("#a-summarise-min", f).value = limits.summarise_min;
|
||||
$("#a-delete", f).hidden = !row;
|
||||
f.addEventListener("input", () => { f.dataset.dirty = "true"; });
|
||||
f.addEventListener("submit", (event) => save(event, row));
|
||||
@@ -227,6 +242,12 @@
|
||||
affinity: Number($("#a-affinity", f).value),
|
||||
taste: Number($("#a-taste", f).value),
|
||||
},
|
||||
limits: {
|
||||
extract_top: Number($("#a-extract-top", f).value),
|
||||
extract_min: Number($("#a-extract-min", f).value),
|
||||
summarise_top: Number($("#a-summarise-top", f).value),
|
||||
summarise_min: Number($("#a-summarise-min", f).value),
|
||||
},
|
||||
// Saving an agent means it is wanted, so a new one starts on; the
|
||||
// card's switch is where an existing one is switched.
|
||||
enabled: row ? row.enabled : true,
|
||||
|
||||
+4
-1
@@ -1083,7 +1083,7 @@ table.applications td[data-label="Saved"] { white-space: nowrap; color: var(--di
|
||||
white-space: pre-line; overflow-wrap: anywhere;
|
||||
}
|
||||
.agent-intent.empty { font-family: inherit; font-size: .9rem; color: var(--dim); font-style: italic; }
|
||||
.agent-weights { margin: 0; font-size: .8rem; color: var(--faint); font-variant-numeric: tabular-nums; }
|
||||
.agent-weights, .agent-limits { margin: 0; font-size: .8rem; color: var(--faint); font-variant-numeric: tabular-nums; }
|
||||
.agent-card-actions { display: flex; align-items: center; flex-wrap: wrap; gap: .5rem 1rem; margin-top: .8rem; }
|
||||
.agent-card-actions a { font-size: .9rem; font-weight: 600; text-decoration: none; }
|
||||
@media (hover: hover) {
|
||||
@@ -1147,6 +1147,9 @@ table.applications td[data-label="Saved"] { white-space: nowrap; color: var(--di
|
||||
.weights { display: flex; gap: .75rem; flex-wrap: wrap; border: 1px solid var(--line); border-radius: .3rem; }
|
||||
/* A label that wraps to two lines pushes its box down; the boxes stay in line. */
|
||||
.weights label { flex: 1 1 6rem; justify-content: space-between; }
|
||||
/* The limits are a pair per stage, count then score, so two to a row. */
|
||||
.weights.limits label { flex: 1 1 40%; }
|
||||
.agent-form fieldset + .hint { margin-top: -.3rem; }
|
||||
.agent-actions { display: flex; gap: .5rem; flex-wrap: wrap; }
|
||||
.agent-form details summary { cursor: pointer; color: var(--dim); font-size: .9rem; }
|
||||
.agent-form details[open] summary { margin-bottom: .5rem; }
|
||||
|
||||
@@ -167,7 +167,9 @@ END;
|
||||
-- A search agent: a named saved search with its own intent text, gates and
|
||||
-- weights. gates is a list of {field, values, mode: require|prefer, weight}.
|
||||
-- intent_vec caches the intent's vector; intent_key is sha1 of the embedding
|
||||
-- model and the intent text, so editing either makes it stale.
|
||||
-- model and the intent text, so editing either makes it stale. limits is how
|
||||
-- deep into this agent's ranking extract and summarise read, as JSON: a key
|
||||
-- it lacks means the `Limits` default.
|
||||
CREATE TABLE IF NOT EXISTS agents (
|
||||
id INTEGER PRIMARY KEY,
|
||||
name TEXT NOT NULL UNIQUE,
|
||||
@@ -177,7 +179,8 @@ CREATE TABLE IF NOT EXISTS agents (
|
||||
enabled INTEGER NOT NULL DEFAULT 1,
|
||||
created_at TEXT NOT NULL,
|
||||
intent_key TEXT NOT NULL DEFAULT '',
|
||||
intent_vec BLOB
|
||||
intent_vec BLOB,
|
||||
limits TEXT NOT NULL DEFAULT '{}'
|
||||
);
|
||||
|
||||
-- One agent's stance on a company: -1 hidden, 0 neutral, 1 liked, 2
|
||||
@@ -331,6 +334,9 @@ ALTER TABLE companies DROP COLUMN affinity;
|
||||
ALTER TABLE companies ADD COLUMN ats TEXT NOT NULL DEFAULT '';
|
||||
ALTER TABLE companies ADD COLUMN country TEXT NOT NULL DEFAULT '';
|
||||
ALTER TABLE companies ADD COLUMN city TEXT NOT NULL DEFAULT '';
|
||||
"""),
|
||||
(8, "agents.limits: how deep into its ranking the model stages read is each agent's own", """
|
||||
ALTER TABLE agents ADD COLUMN limits TEXT NOT NULL DEFAULT '{}';
|
||||
"""),
|
||||
)
|
||||
|
||||
|
||||
+46
-43
@@ -14,7 +14,7 @@ from collections.abc import Callable, Iterator, MutableMapping, Sequence
|
||||
from contextlib import closing, contextmanager
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from typing import Any, Literal
|
||||
from uuid import uuid4
|
||||
|
||||
import numpy as np
|
||||
@@ -22,8 +22,8 @@ import numpy as np
|
||||
from desk.models import Item
|
||||
from app.models import (
|
||||
AFFINITY, REMOTE, STATUSES, Agent, Application, ApplicationEvent, Candidate,
|
||||
Company, Gate, Role, ScoredRole, Subscription, Weights, company_key, country_of,
|
||||
place_key, title_key,
|
||||
Company, Gate, Limits, Role, ScoredRole, Subscription, Weights, company_key,
|
||||
country_of, place_key, title_key,
|
||||
)
|
||||
from app.storage import schema
|
||||
|
||||
@@ -619,24 +619,29 @@ class Store:
|
||||
|
||||
# -------------------------------------------------------------- extract
|
||||
|
||||
def _top_scope(self, per_agent: int, min_score: float) -> tuple[str, list[Any]]:
|
||||
"""The `WHERE` fragment for a role among the `per_agent` best ungated
|
||||
scores of an enabled agent, not below `min_score`: what the two model
|
||||
stages, extract and summarise, are bounded to. The role is `r`. A
|
||||
company an agent hid needs no clause: `score` writes no rows for it
|
||||
under that agent."""
|
||||
return ("""r.uid IN (SELECT uid FROM (
|
||||
SELECT s.uid, s.score, ROW_NUMBER() OVER (
|
||||
def _top_scope(self, stage: Literal["extract", "summarise"]) -> tuple[str, list[Any]]:
|
||||
"""The `WHERE` fragment for a role among the best ungated scores of
|
||||
an enabled agent, as deep and as low as that agent's own `limits`
|
||||
say for `stage`: what the two model stages, extract and summarise,
|
||||
are bounded to. The rank is numbered per agent and the agent's
|
||||
limits ride out of the window subquery beside it, so each row is
|
||||
held to the limits of the agent that ranked it; a key the JSON lacks
|
||||
is the `Limits` default. The role is `r`. A company an agent hid
|
||||
needs no clause: `score` writes no rows for it under that agent."""
|
||||
defaults = Limits()
|
||||
return (f"""r.uid IN (SELECT uid FROM (
|
||||
SELECT s.uid, s.score, a.limits, ROW_NUMBER() OVER (
|
||||
PARTITION BY s.agent_id
|
||||
ORDER BY s.score DESC, top.first_seen DESC, s.uid) AS n
|
||||
FROM scores s
|
||||
JOIN agents a ON a.id = s.agent_id AND a.enabled = 1
|
||||
JOIN roles top ON top.uid = s.uid AND top.closed_at IS NULL
|
||||
WHERE s.gated_reason = '')
|
||||
WHERE n <= ? AND score >= ?)""", [per_agent, min_score])
|
||||
WHERE n <= COALESCE(json_extract(limits, '$.{stage}_top'), ?)
|
||||
AND score >= COALESCE(json_extract(limits, '$.{stage}_min'), ?))""",
|
||||
[getattr(defaults, f"{stage}_top"), getattr(defaults, f"{stage}_min")])
|
||||
|
||||
def _extract_scope(self, per_agent: int, min_score: float,
|
||||
uids: Sequence[str] | None) -> tuple[str, list[Any]]:
|
||||
def _extract_scope(self, uids: Sequence[str] | None) -> tuple[str, list[Any]]:
|
||||
"""The `WHERE` for a role `extract` may read: open, never answered,
|
||||
not given up. Given `uids`, those of them and nothing else, since a
|
||||
batch asks again when it runs and must finish what it was dealt;
|
||||
@@ -646,21 +651,21 @@ class Store:
|
||||
if uids is not None:
|
||||
where.append("r.uid IN (SELECT value FROM json_each(?))")
|
||||
return " AND ".join(where), [json.dumps(list(uids))]
|
||||
top, params = self._top_scope(per_agent, min_score)
|
||||
top, params = self._top_scope("extract")
|
||||
return " AND ".join([*where, top]), params
|
||||
|
||||
def extract_pending(self, per_agent: int, min_score: float = 0.0) -> int:
|
||||
where, params = self._extract_scope(per_agent, min_score, None)
|
||||
def extract_pending(self) -> int:
|
||||
where, params = self._extract_scope(None)
|
||||
row = self._row(f"SELECT COUNT(*) AS n FROM roles r WHERE {where}", params)
|
||||
return int(row["n"]) if row else 0
|
||||
|
||||
def extract_waiting(self, limit: int, per_agent: int, min_score: float = 0.0,
|
||||
uids: Sequence[str] | None = None) -> list[Role]:
|
||||
"""Roles `extract` has yet to read, newest first: the best
|
||||
`per_agent` of every enabled agent's scores not below `min_score`, so
|
||||
the backlog follows the rankings rather than the boards. Given
|
||||
`uids`, only those of them still waiting, whatever their rank."""
|
||||
where, params = self._extract_scope(per_agent, min_score, uids)
|
||||
def extract_waiting(self, limit: int, uids: Sequence[str] | None = None) -> list[Role]:
|
||||
"""Roles `extract` has yet to read, newest first: the best of every
|
||||
enabled agent's scores, as deep and as low as that agent's own
|
||||
`limits` say, so the backlog follows the rankings rather than the
|
||||
boards. Given `uids`, only those of them still waiting, whatever
|
||||
their rank."""
|
||||
where, params = self._extract_scope(uids)
|
||||
return [Role.from_row(r) for r in self._rows(
|
||||
f"SELECT r.* FROM roles r WHERE {where} "
|
||||
"ORDER BY r.first_seen DESC, r.uid LIMIT ?", [*params, limit])]
|
||||
@@ -722,8 +727,7 @@ class Store:
|
||||
#: roles in some agent's top list.
|
||||
_SUMMARY_MISSED = "summarise.missed:"
|
||||
|
||||
def _summary_scope(self, per_agent: int, min_score: float,
|
||||
uids: Sequence[str] | None) -> tuple[str, list[Any]]:
|
||||
def _summary_scope(self, uids: Sequence[str] | None) -> tuple[str, list[Any]]:
|
||||
"""The `WHERE` for a role `summarise` may be sent: no summary yet and
|
||||
some text to summarise. Given `uids`, those of them and nothing else,
|
||||
open or not and given up or not, because somebody asked for them.
|
||||
@@ -733,7 +737,7 @@ class Store:
|
||||
if uids is not None:
|
||||
where.append("r.uid IN (SELECT value FROM json_each(?))")
|
||||
return " AND ".join(where), [json.dumps(list(uids))]
|
||||
top, params = self._top_scope(per_agent, min_score)
|
||||
top, params = self._top_scope("summarise")
|
||||
where += [
|
||||
"r.closed_at IS NULL",
|
||||
f"""NOT EXISTS (SELECT 1 FROM state
|
||||
@@ -743,20 +747,18 @@ class Store:
|
||||
]
|
||||
return " AND ".join(where), params
|
||||
|
||||
def summarise_pending(self, per_agent: int, min_score: float = 0.0) -> int:
|
||||
where, params = self._summary_scope(per_agent, min_score, None)
|
||||
def summarise_pending(self) -> int:
|
||||
where, params = self._summary_scope(None)
|
||||
row = self._row(f"SELECT COUNT(*) AS n FROM roles r WHERE {where}", params)
|
||||
return int(row["n"]) if row else 0
|
||||
|
||||
def summarise_waiting(self, limit: int, per_agent: int,
|
||||
uids: Sequence[str] | None = None,
|
||||
min_score: float = 0.0) -> list[Role]:
|
||||
"""Roles `summarise` has yet to write, newest first. The top
|
||||
`per_agent` of every enabled agent's scores not below `min_score`, so
|
||||
the backlog is bounded by the number of agents rather than by the
|
||||
number of open roles; given `uids`, those still without a summary,
|
||||
whatever their rank. A batch asks again when it runs."""
|
||||
where, params = self._summary_scope(per_agent, min_score, uids)
|
||||
def summarise_waiting(self, limit: int, uids: Sequence[str] | None = None) -> list[Role]:
|
||||
"""Roles `summarise` has yet to write, newest first: the top of every
|
||||
enabled agent's scores, as deep and as low as that agent's own
|
||||
`limits` say, so the backlog is bounded by the agents rather than by
|
||||
the number of open roles; given `uids`, those still without a
|
||||
summary, whatever their rank. A batch asks again when it runs."""
|
||||
where, params = self._summary_scope(uids)
|
||||
return [Role.from_row(r) for r in self._rows(
|
||||
f"SELECT r.* FROM roles r WHERE {where} "
|
||||
"ORDER BY r.first_seen DESC, r.uid LIMIT ?", [*params, limit])]
|
||||
@@ -866,24 +868,25 @@ class Store:
|
||||
|
||||
def save_agent(self, name: str, intent: str = "", gates: Sequence[Gate] = (),
|
||||
weights: Weights | None = None, enabled: bool = True,
|
||||
agent_id: int | None = None) -> Agent:
|
||||
agent_id: int | None = None, limits: Limits | None = None) -> Agent:
|
||||
"""Create an agent, or with `agent_id` replace that one's fields.
|
||||
Raises ValueError on an empty or taken name, KeyError on an unknown id."""
|
||||
name = name.strip()
|
||||
if not name:
|
||||
raise ValueError("an agent needs a name")
|
||||
fields = (name, intent, json.dumps([g.model_dump() for g in gates]),
|
||||
(weights or Weights()).model_dump_json(), int(enabled))
|
||||
(weights or Weights()).model_dump_json(),
|
||||
(limits or Limits()).model_dump_json(), int(enabled))
|
||||
try:
|
||||
with self.transaction() as conn:
|
||||
if agent_id is None:
|
||||
agent_id = conn.execute(
|
||||
"""INSERT INTO agents (name, intent, gates, weights, enabled,
|
||||
created_at) VALUES (?,?,?,?,?,?)""",
|
||||
"""INSERT INTO agents (name, intent, gates, weights, limits,
|
||||
enabled, created_at) VALUES (?,?,?,?,?,?,?)""",
|
||||
(*fields, self.now())).lastrowid
|
||||
elif not conn.execute(
|
||||
"""UPDATE agents SET name=?, intent=?, gates=?, weights=?,
|
||||
enabled=? WHERE id=?""",
|
||||
limits=?, enabled=? WHERE id=?""",
|
||||
(*fields, agent_id)).rowcount:
|
||||
raise KeyError(agent_id)
|
||||
except sqlite3.IntegrityError as exc:
|
||||
|
||||
@@ -30,6 +30,14 @@
|
||||
<label>Companies you like <input type="number" id="a-affinity" min="0" step="0.05" value="0.2"></label>
|
||||
<label>Roles you liked <input type="number" id="a-taste" min="0" step="0.05" value="0.2"></label>
|
||||
</fieldset>
|
||||
<fieldset class="weights limits">
|
||||
<legend>What the model reads</legend>
|
||||
<label>Extract the best <input type="number" id="a-extract-top" min="0" step="10" value="500"></label>
|
||||
<label>down to a score of <input type="number" id="a-extract-min" min="0" max="1" step="0.05" value="0.3"></label>
|
||||
<label>Summarise the best <input type="number" id="a-summarise-top" min="0" step="5" value="30"></label>
|
||||
<label>down to a score of <input type="number" id="a-summarise-min" min="0" max="1" step="0.05" value="0.5"></label>
|
||||
</fieldset>
|
||||
<span class="hint">Every pull scores every open role for free; these bound what the model then reads, per agent. The count is the backstop, the score the real stop. A new role with the worst fit scores about 0.27, a good one 0.6 or more.</span>
|
||||
<details class="advanced">
|
||||
<summary>Advanced</summary>
|
||||
<label>Gates
|
||||
|
||||
+4
-3
@@ -16,8 +16,8 @@ from pydantic import BaseModel, Field
|
||||
|
||||
from app import jobs
|
||||
from app.models import (
|
||||
AFFINITY, Agent, Application, Company, Gate, Role, ScoredRole, Status, Subscription,
|
||||
Weights, company_key,
|
||||
AFFINITY, Agent, Application, Company, Gate, Limits, Role, ScoredRole, Status,
|
||||
Subscription, Weights, company_key,
|
||||
)
|
||||
from app.storage import Store
|
||||
from app.web.deps import ConfigDep, StoreDep
|
||||
@@ -538,6 +538,7 @@ class AgentBody(BaseModel):
|
||||
intent: str = ""
|
||||
gates: list[Gate] = []
|
||||
weights: Weights = Weights()
|
||||
limits: Limits = Limits()
|
||||
enabled: bool = True
|
||||
|
||||
|
||||
@@ -547,7 +548,7 @@ def save_agent(body: AgentBody, store: StoreDep) -> Agent:
|
||||
page starts after a save."""
|
||||
try:
|
||||
return store.save_agent(body.name, body.intent, body.gates, body.weights,
|
||||
body.enabled, agent_id=body.id)
|
||||
body.enabled, agent_id=body.id, limits=body.limits)
|
||||
except ValueError as exc:
|
||||
raise HTTPException(409, str(exc)) from exc
|
||||
except KeyError:
|
||||
|
||||
Reference in new issue
Block a user