Merge pull request #1 from taurean/claude/add-agent-tools-field-01DARfGKcaQurcxg1downZ2B

Add externalServices field to agent autonomy declaration

.env.example

···
 # AUTOMATION_DESCRIPTION="refuses to open pod bay doors"
 # DISCLOSURE_URL="example.com/bot-policy"
 # RESPONSIBLE_PARTY_BSKY="DID:... or example.bsky.app, no @symbol"
+# EXTERNAL_SERVICES="Letta, Railway, Google Gemini 2.5-pro"
 # PRESERVE_MEMORY_BLOCKS=true

README.md

···
 - **`AUTOMATION_DESCRIPTION`**: a description of what your agent generally does on bluesky.
 - **`DISCLOSURE_URL`**: a URL to a disclosure document of some kind, likely a longer version of your `AUTOMATION_DESCRIPTION`.
 - **`RESPONSIBLE_PARTY_BSKY`**: the DID or bluesky handle of the responsible party
+- **`EXTERNAL_SERVICES`**: a comma-separated list of external tools and services your agent relies on outside of Bluesky (e.g., "Letta, Railway, Google Gemini 2.5-pro"). This information is added to your agent's autonomy declaration record on the PDS and included in the agent's memory for transparency.
 - **`PRESERVE_MEMORY_BLOCKS`**: a boolean for controlling if your agent's memory blocks can be overridden if you run `deno task mount` more than once. Setting this value to **`true`** will allow your agent's version of those memory blocks to persist if they already exist. This is false by default.

memories/maintainerContact.ts

···
       : ""
   }
 
+  ${
+    agentContext.externalServices && agentContext.externalServices.length > 0
+      ? `
+**External Services I Rely On:**
+${agentContext.externalServices.map((service) => `- ${service}`).join("\n")}
+    `
+      : ""
+  }
+
   **When to share this information:**
 
   - **Sharing this information should be exceedingly rare.** This exists so my maintainer remains accountable for my behavior, not as information to share casually.

utils/agentContext.ts

···
   );
 };
 
+export const getExternalServices = (): string[] | undefined => {
+  const value = Deno.env.get("EXTERNAL_SERVICES")?.trim();
+
+  if (!value?.length) {
+    return undefined;
+  }
+
+  // Parse comma-separated list
+  const services = value
+    .split(",")
+    .map((service) => service.trim())
+    .filter((service) => service.length > 0);
+
+  if (services.length === 0) {
+    return undefined;
+  }
+
+  // Validate each service string
+  for (const service of services) {
+    if (service.length > 200) {
+      throw Error(
+        `External service name too long: "${service.substring(0, 50)}..." (max 200 characters)`,
+      );
+    }
+  }
+
+  // Validate array length
+  if (services.length > 20) {
+    throw Error(
+      `Too many external services specified: ${services.length} (max 20)`,
+    );
+  }
+
+  return services;
+};
+
 const populateAgentContext = async (): Promise<agentContextObject> => {
   console.log("building new agentContext object…");
   const context: agentContextObject = {
···
   const responsiblePartyBsky = await getResponsiblePartyBsky();
   if (responsiblePartyBsky) {
     context.responsiblePartyBsky = responsiblePartyBsky;
+  }
+
+  const externalServices = getExternalServices();
+  if (externalServices) {
+    context.externalServices = externalServices;
   }
   console.log(
     `\`agentContext\` object built for ${context.agentBskyName}, BEGIN TASK…`,

utils/declaration.ts

···
 import { bsky } from "../utils/bsky.ts";
 import type { AutonomyDeclarationRecord } from "./types.ts";
 import { Lexicons } from "@atproto/lexicon";
+import { agentContext } from "./agentContext.ts";
 
 export const AUTONOMY_DECLARATION_LEXICON = {
   "lexicon": 1,
···
             "description":
               "URL with additional information about this account's automation",
           },
+          "externalServices": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "maxLength": 200,
+            },
+            "maxLength": 20,
+            "description":
+              "External tools and services this agent relies on outside of Bluesky (e.g., 'Letta', 'Railway', 'Google Gemini 2.5-pro')",
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime",
···
   // Add disclosure URL if provided
   if (disclosureUrl?.trim()) {
     declarationRecord.disclosureUrl = disclosureUrl.trim();
+  }
+
+  // Add external services from agentContext (already parsed and validated)
+  if (agentContext.externalServices) {
+    declarationRecord.externalServices = agentContext.externalServices;
   }
 
   // Build responsible party object if any fields are provided

utils/types.ts

···
   automationDescription?: string; // short description of what this agent does
   disclosureUrl?: string; // url to a ToS/Privacy Policy style page
   responsiblePartyBsky?: string; // handle w/o @ or DID of responsible party
+  externalServices?: string[]; // external tools/services this agent relies on
 };
 
 export type AutonomyDeclarationRecord = {
···
 
   // Where can someone learn more?
   disclosureUrl?: string; // URI format
+
+  // What external tools/services does this agent rely on?
+  externalServices?: string[]; // e.g., ["Letta", "Railway", "Google Gemini 2.5-pro"]
 
   // When was this declaration created?
   createdAt: string; // ISO datetime (required)