jev-agent-tools 0.2.0 → 0.3.0

package/dist/mcp/tools.js

@@ -2,15 +2,19 @@ import { Value } from "@sinclair/typebox/value";
 import { spawnExec } from "../adapters/exec.js";
 import { ConfigController } from "../configuration.js";
 import { MCP_VALIDATION_MAX_ERRORS } from "../constants.js";
+import { resultIsError } from "../core/result-report.js";
 import { Guide } from "../guide.js";
 import { mcpHost } from "../host.js";
+import { mcpStructuredResultSchema } from "../report-schema.js";
 import { readSessionLimits, Session } from "../session.js";
+import { renderAgentInstructions } from "../texts/instructions.js";
 import { createAskTool } from "../tools/ask.js";
 import { createAskFilesTool } from "../tools/ask-files.js";
 import { createCheckDiffTool } from "../tools/check-diff.js";
 import { createFindFilesTool } from "../tools/find.js";
 import { createLocateTool } from "../tools/locate.js";
 import { createSelectTestsTool } from "../tools/select-tests.js";
+import { McpInvalidParams } from "./protocol.js";
 function validationError(schema, value) {
     if (Value.Check(schema, value))
         return undefined;
@@ -34,17 +38,20 @@ export async function loadMcpClient(env, configDirectory) {
             env,
             ...(configDirectory ? { directory: configDirectory } : {}),
         });
+        const configured = () => controller.client
+            ? { client: controller.client, apiKey: controller.values().apiKey }
+            : {};
         try {
             await controller.initialize({});
         }
         catch (error) {
             // Saved storage unusable: environment configuration (if any) still applies.
             return {
-                ...(controller.client ? { client: controller.client } : {}),
+                ...configured(),
                 warning: error instanceof Error ? error.message : String(error),
             };
         }
-        return controller.client ? { client: controller.client } : {};
+        return configured();
     }
     catch (error) {
         return { warning: error instanceof Error ? error.message : String(error) };
@@ -58,12 +65,14 @@ export async function createMcpTools(options) {
     const env = options.env ?? process.env;
     const host = mcpHost();
     const loaded = options.client
-        ? { client: options.client }
+        ? { client: options.client, apiKey: env.JEV_TOOLS_API_KEY }
         : await loadMcpClient(env, options.configDirectory);
     const client = loaded.client;
     const dependencies = {
         client,
+        apiKey: loaded.apiKey,
         host,
+        evidenceOrigin: "server",
         runtime: {
             session: new Session(readSessionLimits(env)),
             guide: new Guide(host),
@@ -96,17 +105,21 @@ export async function createMcpTools(options) {
                 // Evidence is sent to the configured judgment endpoint.
                 openWorldHint: true,
             },
+            outputSchema: mcpStructuredResultSchema,
             async call(args, signal) {
                 const invalid = validationError(tool.parameters, args);
                 if (invalid)
-                    return { content: [{ type: "text", text: invalid }], isError: true };
+                    throw new McpInvalidParams(invalid);
                 const result = await tool.execute(`mcp-${++id}`, args, signal, undefined, { cwd: options.root });
-                return { content: result.content };
+                return {
+                    content: result.content,
+                    structuredContent: { result: result.details.result },
+                    ...(resultIsError(result.details.result) ? { isError: true } : {}),
+                };
             },
         };
     });
-    const guidelines = harness.flatMap((tool) => tool.promptGuidelines ?? []);
-    const instructions = [dependencies.runtime.guide.text, ...guidelines].join("\n\n");
+    const instructions = renderAgentInstructions("mcp", host.names);
     return {
         tools,
         instructions,

package/dist/render.js

@@ -40,3 +40,75 @@ function renderLine(line) {
 export function renderEnvelope(envelope) {
     return envelope.lines.map(renderLine).join("\n");
 }
+function knowledge(value, format = String) {
+    return value.status === "known"
+        ? format(value.value)
+        : `${value.status} (${value.reason})`;
+}
+function scopeLabel(scope) {
+    return scope.kind === "call"
+        ? "call"
+        : scope.kind === "item"
+            ? `items ${scope.itemIds.join(", ")}`
+            : scope.kind === "group"
+                ? `groups ${scope.groupIds.join(", ")}`
+                : `inventory ${scope.inventoryIds.join(", ")}`;
+}
+/** Human projection uses the same typed facts as structured transport, never prose inference. */
+export function renderResultReport(report, options = {}) {
+    const { context: c, accounting: a } = report;
+    const counts = a.requestedResults;
+    const mode = counts.fresh + counts.cache
+        ? `${counts.fresh} fresh / ${counts.cache} cache Jev results`
+        : counts.static
+            ? "static selection; no Jev judgment"
+            : report.items.some((item) => item.selection?.selected)
+                ? "conservative fallback selection; no Jev judgment"
+                : "no admissible judgment";
+    const lines = [
+        `${report.execution} — ${mode}${counts.notJudged ? `; ${counts.notJudged} not judged` : ""}`,
+        `context: authority ${knowledge(c.authority, (v) => `${v.path} (${v.origin})`)} · requested root ${knowledge(c.requestedRoot)} · effective root ${knowledge(c.effectiveRoot, (v) => `${v.path} (${v.origin}); common-dir ${knowledge(v.commonDir)}`)} · base ${knowledge(c.requestedBase)} → ${knowledge(c.resolvedBase)}`,
+    ];
+    for (const inv of c.inventories) {
+        lines.push(`inventory ${inv.id} (${inv.kind}): discovered ${knowledge(inv.discovered)} · considered ${knowledge(inv.considered)} · scopeRestricted ${inv.scopeRestricted} · rules ${inv.rules.join("; ")} · restrictions ${inv.restrictions.join("; ") || "none"}`);
+        for (const criterion of inv.criteria)
+            lines.push(`criterion ${JSON.stringify(criterion.criterion)}: ${criterion.outcome}; matches ${knowledge(criterion.matches)}`);
+    }
+    if (c.command.execution !== "not_requested")
+        lines.push(`command: ${c.command.execution} · cwd ${knowledge(c.command.cwd)} · exit ${knowledge(c.command.exitCode)} · timedOut ${knowledge(c.command.timedOut)}`);
+    for (const item of report.items) {
+        if (item.treatment === "judged") {
+            const j = item.judgment;
+            lines.push(`${j.band === "verdict" ? "" : `${j.band}  `}${j.uncalibrated ? "uncalibrated  " : ""}${item.label} = ${String(j.result)} (${j.measure.kind} ${knowledge(j.measure.value)}) [${item.source}]${j.reason ? ` — ${j.reason}` : ""}`);
+            for (const raw of j.rawValues)
+                lines.push(`  raw ${raw.label} = ${String(raw.value)}; probability ${knowledge(raw.probability)}`);
+            for (const control of j.controls) {
+                lines.push(`  control ${control.id} (${control.kind}, ${control.source}): ${control.outcome}`);
+                for (const raw of control.rawValues)
+                    lines.push(`    raw ${raw.label} = ${String(raw.value)}; probability ${knowledge(raw.probability)}`);
+            }
+        }
+        else
+            lines.push(`${item.treatment === "static" ? "static" : "unjudged"}  ${item.label}${item.treatment === "static" ? ` — ${item.staticReason}` : ""}`);
+        for (const evidence of item.evidence)
+            lines.push(`  evidence ${evidence.target} (${evidence.side}): ${knowledge(evidence.canonicalPath)} · aliases ${evidence.aliases.join(", ") || "none"} · revision ${knowledge(evidence.revision)}`);
+        if (item.selection)
+            lines.push(`  selection: ${item.selection.selected ? "selected" : "not selected"} — ${item.selection.reason}`);
+        if (item.diagnosticIds.length)
+            lines.push(`  diagnostics ${item.diagnosticIds.join(", ")}`);
+        if (item.actionIds.length)
+            lines.push(`  actions ${item.actionIds.join(", ")}`);
+    }
+    // Complete diagnostic lists keep legacy text-only clients self-contained.
+    for (const d of report.diagnostics)
+        lines.push(`${d.material ? "material " : ""}${d.effect} ${d.id} — ${d.cause}: ${d.fact} · target ${knowledge(d.target)} · origin ${d.origin} · scope ${scopeLabel(d.scope)} · members ${knowledge(d.memberCount)}${d.omittedMembers.length ? ` · omitted ${d.omittedMembers.join(", ")}` : ""} · actions ${d.actionIds.join(", ") || "none"}`);
+    for (const action of report.actions)
+        lines.push(`next ${action.id} (${action.code}; ${scopeLabel(action.scope)}; target ${knowledge(action.target)}): ${action.condition} — ${action.instruction}`);
+    if (options.details) {
+        const detailLines = options.details.lines.filter((line) => line.type === "command" || line.type === "list");
+        if (detailLines.length)
+            lines.push("details:", renderEnvelope({ lines: detailLines }));
+    }
+    lines.push(`HTTP attempts ${a.httpAttempts} · questions sent ${a.questionsSent} · requested results total ${knowledge(counts.total)} / fresh ${counts.fresh} / cache ${counts.cache} / not judged ${counts.notJudged} / static ${counts.static} · cache probes ${a.cacheHits}/${a.cacheRequests} · auxiliary controls fresh ${a.auxiliary.controls.fresh} / cache ${a.auxiliary.controls.cache} / not judged ${a.auxiliary.controls.notJudged} / static ${a.auxiliary.controls.static} · passages fresh ${a.auxiliary.passages.fresh} / cache ${a.auxiliary.passages.cache} / not judged ${a.auxiliary.passages.notJudged} · current cost USD ${knowledge(a.costUsd)} · elapsed ${a.elapsedMs} ms`);
+    return lines.join("\n");
+}