agency-lang 0.15.0 → 0.16.0

package/dist/lib/agentTarget.d.ts

@@ -29,7 +29,7 @@ export type EvalTarget = {
     label: string;
 };
 /** Resolve the runner-side agent choice. Exactly one of --agent /
- *  --agent-cmd; the command's {task} placeholder is validated here, before
+ *  --agent-cmd; the command's {input} placeholder is validated here, before
  *  any run. Commands come ONLY from these flags, never from suite content —
  *  suites can be remote git sources, and a suite that named its own command
  *  would be remote code execution. */
@@ -38,15 +38,20 @@ export declare function resolveEvalTarget(opts: {
     agentCmd?: string;
 }): EvalTarget;
 /**
- * Fail fast when the entry node cannot receive a task: eval delivers the
- * input's task as the node's single positional parameter, so the node must
- * take exactly one. The subprocess bootstrap enforces the same rule at run
- * time (resolveNodeCallArgs), but by then a workdir has been seeded and the
- * agent compiled — and the optimizer would pay that once per candidate.
- * A misconfigured agent should cost one error, not a suite of run failures.
+ * Fail fast when the agent's shape does not match what the tests deliver.
+ * A test's input reaches a file agent as the entry node's single positional
+ * parameter and a command agent as `{input}`; a test with no input reaches a
+ * node that takes none / a command with no placeholder. Within one suite the
+ * tests must agree (all carry an input, or none does), so the agent has one
+ * shape to be. Checked before any workdir is seeded or agent compiled: a
+ * mis-shaped agent is a configuration error, not a per-test run failure —
+ * and the optimizer would pay it once per candidate. The subprocess
+ * bootstrap re-checks the file case at run time (resolveNodeCallArgs).
  *
- * Best-effort: an unreadable or unparseable file, or a node defined
- * elsewhere than the entry file, is left for compile/run to report with
- * better errors than a pre-parse could.
+ * The file check is best-effort: an unreadable or unparseable file, or a
+ * node defined elsewhere than the entry file, is left for compile/run to
+ * report with better errors than a pre-parse could.
  */
-export declare function assertEvalEntryNodeTakesOneParameter(agentFile: string, node: string): void;
+export declare function assertTargetMatchesInputs(target: EvalTarget, tests: {
+    input?: unknown;
+}[]): void;

package/dist/lib/agentTarget.js

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { MISSING_TASK_PLACEHOLDER_ERROR, TASK_PLACEHOLDER, tokenizeCommand } from "./eval/run/commandLine.js";
+import { MISSING_INPUT_PLACEHOLDER_ERROR, INPUT_PLACEHOLDER, OLD_TASK_PLACEHOLDER, OLD_TASK_PLACEHOLDER_ERROR, tokenizeCommand, } from "./eval/run/commandLine.js";
 import { parseAgency } from "./parser.js";
 /**
  * How an agent target string is parsed and resolved. A target names an agent
@@ -28,56 +28,87 @@ export function resolveEvalRunTarget(target) {
     return { agentFile, node, label: `${agentFile}:${node}` };
 }
 /** Resolve the runner-side agent choice. Exactly one of --agent /
- *  --agent-cmd; the command's {task} placeholder is validated here, before
+ *  --agent-cmd; the command's {input} placeholder is validated here, before
  *  any run. Commands come ONLY from these flags, never from suite content —
  *  suites can be remote git sources, and a suite that named its own command
  *  would be remote code execution. */
 export function resolveEvalTarget(opts) {
     if ((opts.agent ? 1 : 0) + (opts.agentCmd ? 1 : 0) !== 1) {
-        throw new Error("Provide exactly one of --agent or --agent-cmd");
+        throw new Error("Provide exactly one of an agent file or --agent-cmd");
     }
     if (opts.agentCmd) {
-        const tokens = tokenizeCommand(opts.agentCmd);
-        if (!tokens.some((t) => t.includes(TASK_PLACEHOLDER))) {
-            throw new Error(MISSING_TASK_PLACEHOLDER_ERROR);
-        }
-        return { kind: "command", tokens, label: opts.agentCmd };
+        return { kind: "command", tokens: tokenizeCommand(opts.agentCmd), label: opts.agentCmd };
     }
     return { kind: "file", ...resolveEvalRunTarget(opts.agent) };
 }
 /**
- * Fail fast when the entry node cannot receive a task: eval delivers the
- * input's task as the node's single positional parameter, so the node must
- * take exactly one. The subprocess bootstrap enforces the same rule at run
- * time (resolveNodeCallArgs), but by then a workdir has been seeded and the
- * agent compiled — and the optimizer would pay that once per candidate.
- * A misconfigured agent should cost one error, not a suite of run failures.
+ * Fail fast when the agent's shape does not match what the tests deliver.
+ * A test's input reaches a file agent as the entry node's single positional
+ * parameter and a command agent as `{input}`; a test with no input reaches a
+ * node that takes none / a command with no placeholder. Within one suite the
+ * tests must agree (all carry an input, or none does), so the agent has one
+ * shape to be. Checked before any workdir is seeded or agent compiled: a
+ * mis-shaped agent is a configuration error, not a per-test run failure —
+ * and the optimizer would pay it once per candidate. The subprocess
+ * bootstrap re-checks the file case at run time (resolveNodeCallArgs).
  *
- * Best-effort: an unreadable or unparseable file, or a node defined
- * elsewhere than the entry file, is left for compile/run to report with
- * better errors than a pre-parse could.
+ * The file check is best-effort: an unreadable or unparseable file, or a
+ * node defined elsewhere than the entry file, is left for compile/run to
+ * report with better errors than a pre-parse could.
  */
-export function assertEvalEntryNodeTakesOneParameter(agentFile, node) {
+export function assertTargetMatchesInputs(target, tests) {
+    const withInput = tests.filter((test) => test.input !== undefined).length;
+    if (withInput !== 0 && withInput !== tests.length) {
+        throw new Error(`Within one suite either every test provides an "input" or none does; ${withInput} of ${tests.length} do.`);
+    }
+    const hasInput = withInput > 0;
+    if (target.kind === "command") {
+        if (target.tokens.some((t) => t.includes(OLD_TASK_PLACEHOLDER))) {
+            throw new Error(OLD_TASK_PLACEHOLDER_ERROR);
+        }
+        const hasPlaceholder = target.tokens.some((t) => t.includes(INPUT_PLACEHOLDER));
+        if (hasInput && !hasPlaceholder)
+            throw new Error(MISSING_INPUT_PLACEHOLDER_ERROR);
+        if (!hasInput && hasPlaceholder) {
+            throw new Error(`--agent-cmd contains ${INPUT_PLACEHOLDER} but no test provides an input — pass --input <text> ` +
+                `(or give the tests an "input"), or drop the placeholder for an agent that takes none.`);
+        }
+        return;
+    }
+    const count = entryNodeParameterCount(target.agentFile, target.node);
+    if (count === undefined)
+        return;
+    const { names } = count;
+    if (hasInput && names.length !== 1) {
+        const detail = names.length === 0
+            ? `takes none — add one (it may go unused: \`node ${target.node}(task: string) { ... }\`), or drop the input if the agent needs none`
+            : `takes ${names.length} (${names.join(", ")}) — add a one-parameter adapter node`;
+        throw new Error(`eval delivers each test's input as the entry node's single parameter, ` +
+            `but node "${target.node}" in ${target.agentFile} ${detail}.`);
+    }
+    if (!hasInput && names.length !== 0) {
+        throw new Error(`node "${target.node}" in ${target.agentFile} takes ${names.length} (${names.join(", ")}) ` +
+            `but no test provides an input — pass --input <text> (or give the tests an "input"), ` +
+            `or make the node take no parameter.`);
+    }
+}
+/** The entry node's parameter names, or undefined when the file cannot be
+ *  read/parsed or does not define the node (best-effort, see above). */
+function entryNodeParameterCount(agentFile, node) {
     let source;
     try {
         source = fs.readFileSync(agentFile, "utf-8");
     }
     catch {
-        return;
+        return undefined;
     }
     const parsed = parseAgency(source, {}, false);
     if (!parsed.success)
-        return;
+        return undefined;
     for (const candidate of parsed.result.nodes) {
         if (candidate.type !== "graphNode" || candidate.nodeName !== node)
             continue;
-        const count = candidate.parameters.length;
-        if (count !== 1) {
-            const detail = count === 0
-                ? `takes none — add one (it may go unused: \`node ${node}(task: string) { ... }\`)`
-                : `takes ${count} (${candidate.parameters.map((p) => p.name).join(", ")}) — add a one-parameter adapter node`;
-            throw new Error(`eval delivers the input's task as the entry node's single parameter, ` +
-                `but node "${node}" in ${agentFile} ${detail}.`);
-        }
+        return { names: candidate.parameters.map((p) => p.name) };
     }
+    return undefined;
 }

package/dist/lib/agents/agency-agent/agent.agency

@@ -1,141 +1,36 @@
-import { localModelsSupported, listModelNames } from "std::agency/local"
 import { parseArgs } from "std::args"
 import { map } from "std::array"
-import { today } from "std::date"
-import { generateImage } from "std::image"
-import { listHostedModels, hostedModelInfo, setLlmOptions } from "std::llm"
-import { setMemoryId, disableMemory } from "std::memory"
-import { basename, dirname } from "std::path"
-import {
-  ScopedRuleFields,
-  cliPolicyHandler,
-  parsePolicyFile,
-  setPolicy,
-  minimalAutoApprovePolicy,
-  recommendedAutoApprovePolicy,
-  builtinPolicy,
-  builtinPolicyNames,
-  BUILTIN_POLICIES,
- } from "std::policy"
-import { exists } from "std::shell"
-import { commandsDir, expandSlash } from "std::skills"
-import { highlight } from "std::syntax"
+import { setLlmOptions } from "std::llm"
+import { evalOutput, evalValue, setAgentName } from "std::statelog"
 import { cwd, env, isTTY, readStdin, setTitle } from "std::system"
-import {
-  Attachment,
-  attachToReply,
-  getCost,
-  getModelCosts,
-  image,
-  systemMessage,
- } from "std::thread"
-import { chooseOption, ChoiceItem } from "std::ui"
+import { getCost } from "std::thread"
 import {
   clearMessages,
   pushMessage,
   repl,
   clearScreen,
-  clearHistory,
  } from "std::ui/cli"
 
+import { brainByName, allBrains, brainFlagHelp } from "./brains/registry.agency"
+import { agentNameFor } from "./lib/agentName.agency"
 import { parseAgentArgs } from "./lib/args.agency"
-import { detectAttachments, modalityFilter } from "./lib/attachments.agency"
-import { showCapabilities, editCapabilities } from "./lib/capabilitiesUi.agency"
-import { mergedPalette, projectCommands } from "./lib/commandPalette.agency"
-import {
-  POLICY_PATH,
-  SESSION_POLICY_PATH,
-  HISTORY_PATH,
-  ALWAYS_FIELDS,
- } from "./lib/config.agency"
-import {
-  runTurn,
-  setGroundingContext,
-  loadAgentsMd,
-  maybeEnableMemory,
-  checkMainPrompts,
-  START_AGENTS,
- } from "./lib/coordinator.agency"
 import { getHeader } from "./lib/header.agency"
-import { generateImageFile } from "./lib/images.agency"
-import { getMcpTools, maybeLoadMcp, mcpSlashCommand } from "./lib/mcp.agency"
-import { filterHostedModels, ModelFilters } from "./lib/modelFilters.agency"
-import {
-  parseModelFlag,
-  parseModelSpec,
-  knownProviders,
-  missingProviderEnvVar,
-  Resolved,
- } from "./lib/models.agency"
-import {
-  givePolicyChoice,
-  printPolicyHelp,
-  getPolicyForAgent,
- } from "./lib/policy.agency"
-import { startInteractive, renderAgentResponse } from "./lib/repl.agency"
-import {
-  buildLayers,
-  resolveAll,
-  diffResolved,
-  Ctx,
-  SlotChange,
- } from "./lib/resolution.agency"
-import {
-  configureSearch,
-  setSearchBackend,
-  getSearchBackend,
-  availableBackendItems,
- } from "./lib/search.agency"
-import {
-  Session,
-  switchModel,
-  reactToSlotChange,
-  modelChoiceItems,
-  parseModelsFilters,
-  markMemoryEmbeddingsPinned,
-  pickModelsForAgent,
- } from "./lib/session.agency"
-import {
-  getCapabilitySettings,
-  getModelSettings,
-  loadSettings,
-  saveSettings,
- } from "./lib/settings.agency"
-import { SLOTS } from "./lib/slots.agency"
+import { maybeLoadMcp } from "./lib/mcp.agency"
+import { printPolicyHelp } from "./lib/policy.agency"
+import { startInteractive } from "./lib/repl.agency"
+import { pickModelsForAgent, maybeEnableMemory } from "./lib/session.agency"
+import { loadSettings } from "./lib/settings.agency"
 import { setDebug, setVerbose, setInteractive } from "./lib/trace.agency"
 import {
-  truncate,
-  formatArgs,
-  formatToolResponse,
-  retryReasonLabel,
-  formatTurnFailure,
- } from "./lib/utils.agency"
-import { renderLLMCallResponse } from "./lib/utils/renderLLMCallResponse.agency"
-import {
-  configureModels,
-  configureLocalModel,
-  enableAgentMemory,
-  getResolvedSlots,
-  applyResolved,
-  promoteAll,
-  currentProvider,
-  resolveMaxToolCallRounds,
-  getCapabilities,
-  getCapabilitiesResolved,
-  getCapabilityModelKey,
-  getCapabilityProvider,
-  refreshCapabilities,
-  embeddingKeyStatus,
-  memoryEnablePlan,
-  overrideFromResolved,
-  embeddingsOverride,
-  providerEnvMissing,
- } from "./shared.agency"
-import { codeAgent, setCodeOneShot } from "./subagents/code.agency"
-import { explorerAgent } from "./subagents/explorer.agency"
-import { oracleAgent } from "./subagents/oracle.agency"
-import { researchAgent } from "./subagents/research.agency"
-import { reviewAgent } from "./subagents/review.agency"
+  setBrain,
+  runTurn,
+  runSession,
+  setPolicyArg,
+  resolveBrainName,
+  resolveStartTarget,
+ } from "./lib/turn.agency"
+import { formatTurnFailure } from "./lib/utils.agency"
+import { resolveMaxToolCallRounds, getCapabilities } from "./shared.agency"
 
 
 // UI mode select — one-line swap between the alt-screen TUI and the
@@ -146,44 +41,25 @@ import { reviewAgent } from "./subagents/review.agency"
 //
 //import { clearMessages, pushMessage, repl } from "std::ui"
 
-// The `--policy` argument (a built-in name or a policy-file path), or "" when
-// absent. CLI-owned: main() sets it, setupSession() reads it.
-let _policyArg: string = ""
-
-
-def setupSession(interactive: boolean): any {
-  setAgentCwd(cwd())
-
-  // Grounding: the LLM shouldn't have to ask where it is or what day it
-  // is. Also load `AGENTS.md` if present.
-  const projectContext = loadAgentsMd(cwd()) with approve
-  const grounding = """
-
-  Current date: ${today()}
-  Current working directory: ${cwd()}
-  ${projectContext}
-  """
-  setGroundingContext(grounding)
-
-  const { policyFile, sessionPolicy } = getPolicyForAgent(_policyArg, interactive)
-
-  return cliPolicyHandler(
-    file: policyFile,
-    fields: ALWAYS_FIELDS,
-    policy: sessionPolicy,
-  )
-}
-
 def oneShotAgent(target: string, prompt: string): string {
   setInteractive(false)
-  const handler = setupSession(interactive: false)
-  handle {
+  // Mark the input and reply in the statelog so a one-shot run is gradable:
+  // `agency eval grade` reads the agent's output from the trace's
+  // `evalOutputRecorded` events, not from stdout.
+  evalValue(prompt)
+  let reply = ""
+  runSession(false) {
     const result = try runTurn(target, prompt)
-    return match(result) {
-      success(r) => r
-      failure(f) => formatTurnFailure("${f.error}")
+    // Not `match`: a match expression inside a block body keeps its value on
+    // the wrong stack, so `reply` would end up null (compiler bug).
+    if (result is success(r)) {
+      reply = r
+    } else if (result is failure(f)) {
+      reply = formatTurnFailure("${f.error}")
     }
-  } with handler
+  }
+  evalOutput(reply)
+  return reply
 }
 
 /* A seeded turn is if the user invokes the Agency agent with
@@ -193,7 +69,7 @@ It means that agent starts with an initial prompt already there to respond to. *
 node main() {
   // Parse CLI flags first — `parseArgs` exits on --help / --version /
   // usage errors, before any handlers or the TUI are installed.
-  const args = parseAgentArgs()
+  const args = parseAgentArgs(brainFlagHelp())
 
   // NOTE: --trace / --log / --agent-home are declared here only for
   // --help and so parseArgs accepts them. runBundledAgent extracts them from
@@ -208,8 +84,6 @@ node main() {
     setVerbose(true)
   }
 
-  checkMainPrompts()
-
   // `--policy` is an optional-value flag: a bare `--policy` (no name or
   // path) prints the usage + the built-in policies and exits, rather than
   // silently doing nothing.
@@ -217,7 +91,32 @@ node main() {
     printPolicyHelp()
     process.exit(0)
   }
-  _policyArg = args.flags.policy ?? ""
+  setPolicyArg(args.flags.policy ?? "")
+
+  const brainName = resolveBrainName(args.flags.brain ?? null, loadSettings())
+  const brain = brainByName(brainName)
+  if (brain == null) {
+    const names = map(allBrains(), \entry -> entry.name).join(", ")
+    print(color.red("Unknown --brain value: ${brainName}. Valid: ${names}"))
+    process.exit(1)
+    return
+  }
+  setBrain(brain)
+  // Group this trace under its brain wherever runs are compared.
+  setAgentName(agentNameFor(brain))
+
+  // Validate the --agent target up front, before any model or session setup.
+  const requestedStartTarget = args.flags.agent ?? ""
+  const resolvedStartTarget = resolveStartTarget(brain, requestedStartTarget)
+  let startAgent = ""
+  if (resolvedStartTarget == null) {
+    const validTargets = ["main", ...brain.startTargets].join(", ")
+    print(color.red("Unknown --agent value: ${requestedStartTarget}. Valid for the ${brain.name} brain: ${validTargets}"))
+    process.exit(1)
+    return
+  } else {
+    startAgent = resolvedStartTarget
+  }
 
   pickModelsForAgent(args)
 
@@ -234,16 +133,6 @@ node main() {
   // would otherwise look like a flag.
   const positionalQuery = args.positionals.join(" ")
   const hasQuery = positionalQuery != ""
-  const startAgent = args.flags.agent ?? ""
-  // Validate the target subagent name up front (empty = coordinator).
-  if (startAgent != "" && !START_AGENTS.includes(startAgent)) {
-    print(
-      color.red(
-      "Unknown --agent value: ${startAgent}. Valid: ${START_AGENTS.join(", ")}",
-    ),
-    )
-    process.exit(1)
-  }
 
   const wantInteractive = args.flags.interactive
 
@@ -275,11 +164,7 @@ node main() {
     })
   }
 
-  // One-shot autonomy: tell the code subagent there is no human to answer
-  // questions and no next turn, so it must drive to a finished artifact.
-  // Set before any dispatch so both the pinned `--agent code` path and the
-  // coordinator (which calls codeAgent as a tool) pick it up.
-  setCodeOneShot(isOneShot)
+  setAgentCwd(cwd())
 
   if (isOneShot) {
     let prompt = positionalQuery
@@ -296,8 +181,9 @@ node main() {
   } else {
     setTitle("Agency Agent")
     clearScreen()
-    print(getHeader())
-    const handler = setupSession(interactive: true)
-    startInteractive(handler, startAgent, positionalQuery)
+    print(getHeader(brain.name))
+    runSession(true) {
+      startInteractive(startAgent, positionalQuery)
+    }
   }
 }