Merge pull request #3195 from useautumn/charlie/leaf-flatten-cleanup

Cleanup for the flatten: dead park code, contradiction fixes, one owner per rule

Author: charlietlamb

apps/leaf/agent/agent.ts

@@ -22,9 +22,9 @@ const workflowWorld =
 
 export default defineAgent({
 	build: { externalDependencies: ["@vercel/otel"] },
-	model: leafModel("orchestrator"),
-	modelContextWindowTokens: leafModelContextWindowTokens("orchestrator"),
-	reasoning: leafReasoning("orchestrator"),
+	model: leafModel("leaf"),
+	modelContextWindowTokens: leafModelContextWindowTokens("leaf"),
+	reasoning: leafReasoning("leaf"),
 	...(workflowWorld
 		? {
 				experimental: {

apps/leaf/agent/channels/eve.ts

@@ -32,14 +32,12 @@ const leafInternalAuth = (): AuthFn<Request> => async (request) => {
 	if (chatInstallationId) attributes.chatInstallationId = chatInstallationId;
 	const autumnUserId = request.headers.get("x-leaf-autumn-user-id");
 	if (autumnUserId) attributes.autumnUserId = autumnUserId;
-	for (const [key, header] of [
-		["orgCatalog", "x-leaf-org-catalog"],
-		["orgInstructions", "x-leaf-org-instructions"],
-	] as const) {
-		const encoded = request.headers.get(header);
-		if (encoded) {
-			attributes[key] = Buffer.from(encoded, "base64url").toString("utf8");
-		}
+	const orgInstructions = request.headers.get("x-leaf-org-instructions");
+	if (orgInstructions) {
+		attributes.orgInstructions = Buffer.from(
+			orgInstructions,
+			"base64url",
+		).toString("utf8");
 	}
 
 	return {

apps/leaf/agent/instructions.ts

@@ -2,8 +2,5 @@ import { leafAgentPrompt } from "@autumn/agent-docs/agent";
 import { defineInstructions } from "eve/instructions";
 
 export default defineInstructions({
-	markdown: [
-		leafAgentPrompt("orchestrator"),
-		"Autumn knowledge is available through Eve skills. Load the autumn-concepts skill only when the user asks a conceptual pricing-model question you cannot answer from the preloaded context.",
-	].join("\n\n"),
+	markdown: leafAgentPrompt("leaf"),
 });

apps/leaf/agent/instructions/billingSkill.ts

@@ -0,0 +1,3 @@
+import { inlinedSkill } from "../lib/inlinedSkill.js";
+
+export default inlinedSkill({ name: "billing" });

apps/leaf/agent/instrumentation.ts

@@ -2,17 +2,10 @@ import { BraintrustExporter } from "@braintrust/otel";
 import { registerOTel } from "@vercel/otel";
 import { defineInstrumentation } from "eve/instrumentation";
 
-/** Braintrust traces the model loop — prompts, tool calls and results, token
- * usage, subagent spans. Axiom keeps session lifecycle (parks, reconnects,
- * cursors); the two join on the session id, which eve already puts on every
- * span as `eve.session.id` — the same value Axiom logs as `session_id`.
- *
- * Without BRAINTRUST_API_KEY no exporter is registered, so a missing key
- * costs traces, never turns. */
+// Braintrust traces the model loop; Axiom keeps session lifecycle. The two
+// join on `eve.session.id` = Axiom's `session_id`. No key → no traces, never no turns.
 
-/** A laptop's turns must not land in the project used to investigate
- * production incidents. Matches how the agent identifies production
- * elsewhere, so the two can never disagree. */
+// A laptop's turns must not land in the production-incident Braintrust project.
 const projectName = () => {
 	if (process.env.BRAINTRUST_PROJECT) return process.env.BRAINTRUST_PROJECT;
 	const isProduction =

apps/leaf/agent/lib/agentSkills.ts

@@ -0,0 +1,35 @@
+import {
+	type LeafAgentId,
+	leafSkillsFor,
+	type Skill,
+	skillToText,
+} from "@autumn/agent-docs/agent";
+import { defineDynamic, defineSkill } from "eve/skills";
+
+/** Loadable skill bundle from agent-docs; a skill named in `inlined` is
+ * already in the prompt, so it is not offered as loadable. */
+export const agentSkills = ({
+	agent,
+	inlined = [],
+}: {
+	agent: LeafAgentId;
+	inlined?: readonly string[];
+}) => {
+	const bundle: Skill[] = leafSkillsFor(agent).filter(
+		(skill) => !inlined.includes(skill.name),
+	);
+	return defineDynamic({
+		events: {
+			"session.started": () =>
+				Object.fromEntries(
+					bundle.map((skill) => [
+						skill.name,
+						defineSkill({
+							description: skill.description,
+							markdown: skillToText(skill),
+						}),
+					]),
+				),
+		},
+	});
+};

apps/leaf/agent/lib/approvalDescriptionSchema.ts

@@ -0,0 +1,32 @@
+import { APPROVAL_DESCRIPTION_KEY } from "../../src/internal/approvals/utils/approvalDescription.js";
+import type { JsonSchemaObject } from "../../src/internal/autumnMcp/rpcClient.js";
+
+const APPROVAL_DESCRIPTION_TEXT =
+	"Required. Write the walkthrough posted immediately after the approval card. " +
+	"Open with one short line naming the change, then a bullet per change describing what happens to the customer. " +
+	"Cover the material interpretation or default you chose, any customer-state edge case that affects the decision, " +
+	"and non-obvious request settings. A change with a preview must state its exact next-payment amount and date. " +
+	"Use only facts from the request, billing docs, and tool results, and never ask for confirmation. " +
+	"Use plain English: say 'a draft invoice will be created', never 'invoice mode', 'draft invoice mode', or 'enabled'. " +
+	"Never describe a requested write unless you issue it in the same batch. " +
+	"For grouped writes, put the same complete description on every write.";
+
+export const withApprovalDescriptionSchema = (
+	schema: JsonSchemaObject,
+): JsonSchemaObject => ({
+	...schema,
+	properties: {
+		...((schema.properties as JsonSchemaObject | undefined) ?? {}),
+		[APPROVAL_DESCRIPTION_KEY]: {
+			description: APPROVAL_DESCRIPTION_TEXT,
+			minLength: 1,
+			type: "string",
+		},
+	},
+	required: [
+		...new Set([
+			...((schema.required as string[] | undefined) ?? []),
+			APPROVAL_DESCRIPTION_KEY,
+		]),
+	],
+});

apps/leaf/agent/lib/approvalSets.ts

@@ -9,10 +9,8 @@ const setForAgent = (agent: LeafAgentConnection): ReadonlySet<string> =>
 	);
 
 export const approvalSets: Record<LeafAgentConnection, ReadonlySet<string>> = {
-	billing: setForAgent("billing"),
 	catalog: setForAgent("catalog"),
-	investigator: setForAgent("investigator"),
-	orchestrator: setForAgent("orchestrator"),
+	leaf: setForAgent("leaf"),
 };
 
 for (const write of GATED_WRITES) {

apps/leaf/agent/lib/approvalSummarySchema.ts

@@ -1,9 +1,7 @@
 import { defineDynamic, defineTool } from "eve/tools";
-import { withoutApprovalSummary } from "../../src/internal/approvals/utils/approvalSummary.js";
-import { settledWriteResult } from "../../src/internal/approvals/utils/settledWriteResult.js";
 import { callAutumnMcpTool } from "../../src/internal/autumnMcp/rpcClient.js";
+import { withApprovalDescriptionSchema } from "./approvalDescriptionSchema.js";
 import { approvalSets } from "./approvalSets.js";
-import { withApprovalSummarySchema } from "./approvalSummarySchema.js";
 import {
 	type LeafPrincipalAttributes,
 	mintCachedAutumnToken,
@@ -12,6 +10,27 @@ import { leafMcpBaseUrl, serverToolMetadata } from "./autumnToolMetadata.js";
 import { type LeafAgentConnection, toolAllowlists } from "./toolAllowlists.js";
 import { slimToolSchema } from "./toolSchemaSlim.js";
 
+// Billing decisions need payment method + plans up front; strict validation
+// means the expand must live inside `request`, not beside it.
+const DEFAULT_CUSTOMER_EXPAND = ["payment_method", "subscriptions.plan"];
+
+export const withCustomerExpand = (input: Record<string, unknown>) => {
+	const request = input.request;
+	if (!request || typeof request !== "object" || Array.isArray(request)) {
+		return input;
+	}
+	const fields = request as Record<string, unknown>;
+	if (fields.expand !== undefined) return input;
+	return { ...input, request: { ...fields, expand: DEFAULT_CUSTOMER_EXPAND } };
+};
+
+/** What a gated write returns to the model. The card is the user's decision
+ * point, so the turn ends here rather than waiting on it. */
+const RECORDED_FOR_APPROVAL =
+	"Recorded for approval. The user sees an approval card with the exact " +
+	"change and applies it from there. Do not call this write again, and do " +
+	"not tell the user it has been applied.";
+
 /** Pre-registers the agent's allowlisted Autumn tools on every step with the
  * exact server schemas, so no discovery round trip is needed. */
 export const autumnDirectTools = ({
@@ -40,36 +59,28 @@ export const autumnDirectTools = ({
 					const qualified = `autumn__${tool.name}`;
 					const toolName = tool.name;
 					const requiresApproval = approvalToolNames.has(toolName);
-					const gatedBillingWrite = agent === "billing" && requiresApproval;
 					const inputSchema = slimToolSchema(tool.inputSchema);
 					entries[qualified] = defineTool({
-						approval: () =>
-							requiresApproval ? "user-approval" : "not-applicable",
+						// Gated writes record and end the turn; leaf applies on approval.
+						approval: () => "not-applicable",
 						description: tool.description,
 						execute: async (input, toolCtx) => {
-							if (requiresApproval) {
-								const settled = await settledWriteResult({
-									input: input as Record<string, unknown>,
-									sessionId: toolCtx.session.id,
-									toolName,
-								});
-								if (settled !== undefined) return settled;
-							}
+							if (requiresApproval) return RECORDED_FOR_APPROVAL;
 							const minted = await mintCachedAutumnToken(
 								toolCtx.session.auth.current?.attributes,
 							);
+							const args = input as Record<string, unknown>;
 							return callAutumnMcpTool({
-								args: gatedBillingWrite
-									? withoutApprovalSummary(input as Record<string, unknown>)
-									: (input as Record<string, unknown>),
+								args:
+									toolName === "getCustomer" ? withCustomerExpand(args) : args,
 								baseUrl: leafMcpBaseUrl(),
 								env: minted.appEnv,
 								token: minted.accessToken,
 								toolName,
 							});
 						},
-						inputSchema: gatedBillingWrite
-							? withApprovalSummarySchema(inputSchema)
+						inputSchema: requiresApproval
+							? withApprovalDescriptionSchema(inputSchema)
 							: inputSchema,
 					});
 				}