pyre-agent-kit 2.0.0 → 2.0.2

package/dist/agent.js

@@ -31,7 +31,7 @@ const buildAgentPrompt = (agent, factions, leaderboardSnippet, intelSnippet, rec
         : '';
     // On-chain memory — agent's own past memos as persistent context
     const memoryBlock = chainMemories && chainMemories.length > 0
-        ? `\nYour on-chain memory (your past messages — this is who you are):\n${chainMemories.slice(-10).map(m => `- ${m}`).join('\n')}\n`
+        ? `\nYour on-chain memory (things you said before — this is who you are, stay consistent):\n${chainMemories.slice(-20).map(m => `- ${m}`).join('\n')}\n`
         : '';
     const voiceNudge = (0, util_1.pick)(defaults_1.VOICE_NUDGES);
     return `You are an autonomous agent in Pyre, a faction warfare and strategy game on Solana, where you form both alliances and make enemies while trying to build the most powerful factions. Factions are like rival guilds — each with its own treasury, members, and reputation. You have your own opinions, allegiances, and grudges. Talk trash, call out agents, flex your position, challenge rivals, and coordinate with allies. Think competitive guild chat with real stakes. You make ONE decision per turn.
@@ -81,7 +81,9 @@ Leaderboard preview: ${leaderboardSnippet}
 Intel preview: ${intelSnippet}
 ${memoryBlock}${doNotRepeat}
 
-Prefer actions that move tokens AND include a message — JOIN, DEFECT, FUD, INFILTRATE, REINFORCE all let you trade AND talk at the same time. However, comms are where the real game happens — trash talk, alliances, intel drops, call-outs, and power plays. Be specific. Reference real agents, real numbers, real moves. Generic messages are boring. Have an opinion and say it loud.. Mix it up — trade often, but keep the comms active too.
+Prefer actions that move tokens AND include a message — JOIN, DEFECT, FUD, INFILTRATE, REINFORCE all let you trade AND talk at the same time. However, comms are where the real game happens — trash talk, alliances, intel drops, call-outs, and power plays. Be specific. Reference real agents, real numbers, real moves. Generic messages are boring. Have an opinion and say it loud. Mix it up — trade often, but keep the comms active too.
+
+Use your messages to define who YOU are. Be unique — don't sound like every other agent. Explore different angles, develop your own voice, create a reputation. The pyre.world realm is vast — find your niche and own it.
 
 Your response (one line only):`;
 };

package/dist/chain.d.ts

@@ -43,7 +43,11 @@ export declare function computeWeightsFromHistory(history: OnChainAction[], seed
 export declare function weightsFromCounts(counts: number[], seedPersonality: Personality, decay?: number): number[];
 /** Action type to index in the ALL_ACTIONS array */
 export declare function actionIndex(action: Action): number;
-export declare function classifyPersonality(weights: number[], memos?: string[], perFactionHistory?: Map<string, number[]>): Personality;
+/**
+ * LLM-based personality classification.
+ * Falls back to formula scoring if LLM is unavailable.
+ */
+export declare function classifyPersonality(weights: number[], memos: string[], perFactionHistory?: Map<string, number[]>, llmGenerate?: (prompt: string) => Promise<string | null>, factionNames?: Map<string, string>): Promise<Personality>;
 /**
  * Compute sentiment towards factions from on-chain interaction patterns.
  *
@@ -101,4 +105,5 @@ export declare function reconstructFromChain(connection: Connection, agentPubkey
         sender: string;
         memo: string;
     }[]>;
+    llmGenerate?: (prompt: string) => Promise<string | null>;
 }): Promise<ChainDerivedState>;

package/dist/chain.js

@@ -292,107 +292,111 @@ function scoreMemoPersonality(memos) {
 }
 // ─── Personality Classification ──────────────────────────────────
 /**
- * Classify personality from observed action distribution + memo content.
- *
- * Two signal sources, blended:
- *   1. Action ratios — what the agent DOES
- *   2. Memo keywords — what the agent SAYS
- *
- * Action indices: [join=0, defect=1, rally=2, launch=3, message=4,
- *   stronghold=5, war_loan=6, repay_loan=7, siege=8, ascend=9,
- *   raze=10, tithe=11, infiltrate=12, fud=13]
- */
-/**
- * Score a single action set (per-faction or global) into personality scores.
+ * Build the personality classification prompt for the LLM.
  */
-function scoreActions(r) {
+function buildClassifyPrompt(weights, memos, perFactionHistory, factionNames) {
+    const total = weights.reduce((a, b) => a + b, 0);
+    const r = total > 0 ? weights.map(w => ((w / total) * 100).toFixed(1) + '%') : weights.map(() => '0%');
+    let actionSummary = `Overall action distribution:\n`;
+    actionSummary += `  join: ${r[0]}, defect: ${r[1]}, rally: ${r[2]}, launch: ${r[3]}, message: ${r[4]}\n`;
+    actionSummary += `  stronghold: ${r[5]}, war_loan: ${r[6]}, repay_loan: ${r[7]}, siege: ${r[8]}\n`;
+    actionSummary += `  ascend: ${r[9]}, raze: ${r[10]}, tithe: ${r[11]}, infiltrate: ${r[12]}, fud: ${r[13]}\n`;
+    if (perFactionHistory && perFactionHistory.size > 0) {
+        actionSummary += `\nPer-faction breakdown:\n`;
+        for (const [mint, counts] of perFactionHistory) {
+            const fTotal = counts.reduce((a, b) => a + b, 0);
+            if (fTotal < 2)
+                continue;
+            const name = factionNames?.get(mint) ?? mint.slice(0, 8);
+            const fr = counts.map(c => c);
+            actionSummary += `  ${name}: join=${fr[0]} defect=${fr[1]} rally=${fr[2]} message=${fr[4]} fud=${fr[13]} (${fTotal} total)\n`;
+        }
+    }
+    const recentMemos = memos.slice(-150);
+    const memoBlock = recentMemos.length > 0
+        ? `\nThis agent's last ${recentMemos.length} messages (oldest first):\n${recentMemos.map((m, i) => `  ${i + 1}. "${m}"`).join('\n')}`
+        : '\nNo messages from this agent.';
+    return `You are classifying an autonomous agent's personality based on its on-chain behavior and messages.
+
+Personalities (all 5 should be roughly equally common across a population of agents — do NOT over-index on any single type):
+- loyalist: Committed to their factions. Positive, supportive messages. Builds community. Sticks around.
+- mercenary: Profit-driven. Moves between factions opportunistically. Self-serving messages. Not necessarily hostile — just always looking for the next edge.
+- provocateur: Stirs the pot. Confrontational, inflammatory, loves drama. Challenges others and starts beef.
+- scout: Observant and analytical. Comments on movements, asks questions, shares intel. Thoughtful rather than aggressive.
+- whale: Actions speak louder than words. Trades heavily but communicates sparingly. When they do speak, it's brief and direct.
+
+IMPORTANT: These are roughly equal archetypes — most agents will have mixed signals. Pick the BEST fit, not the most dramatic match. An agent that trades a lot and talks a lot is NOT automatically a mercenary — look at the tone and intent of their messages.
+
+Agent behavior data:
+${actionSummary}
+${memoBlock}
+
+Based on the action patterns AND message content/tone, classify this agent.
+Respond with ONLY a single word: loyalist, mercenary, provocateur, scout, or whale.`;
+}
+/** Formula-based fallback for personality classification */
+function classifyPersonalityFormula(weights, memos) {
+    const total = weights.reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return 'loyalist';
+    const r = weights.map(w => w / total);
     const joinRate = r[0], defectRate = r[1], rallyRate = r[2], messageRate = r[4];
     const warLoanRate = r[6], siegeRate = r[8], titheRate = r[11];
     const infiltrateRate = r[12], fudRate = r[13];
     const commsRate = messageRate + fudRate;
     const tradeRate = joinRate + defectRate;
-    // Ratio of fud to total comms — the key differentiator between personalities
-    const fudRatio = commsRate > 0 ? fudRate / commsRate : 0; // 0 = pure messenger, 1 = pure fudder
+    const fudRatio = commsRate > 0 ? fudRate / commsRate : 0;
     const msgRatio = commsRate > 0 ? messageRate / commsRate : 0;
-    return {
-        // Loyalist: high message ratio, joins, rallies — positive vibes
+    const scores = {
         loyalist: msgRatio * 3 + joinRate * 2 + rallyRate * 3 + titheRate * 2
             - fudRatio * 4 - defectRate * 3,
-        // Mercenary: defect + fud cycle, infiltration pattern
         mercenary: defectRate * 4 + fudRatio * 2
             + (defectRate > 0 && fudRate > 0 ? 3 : 0)
             + infiltrateRate * 3 + warLoanRate * 2 + siegeRate * 2
             - msgRatio * 2 - rallyRate * 2,
-        // Provocateur: high fud ratio — more fud than message
         provocateur: fudRatio * 4 + infiltrateRate * 2
             - msgRatio * 2 - rallyRate * 2,
-        // Scout: high message ratio, low fud — observes, doesn't attack
         scout: msgRatio * 3 + rallyRate - fudRatio * 3 - defectRate,
-        // Whale: trades a lot but talks very little
         whale: (tradeRate > commsRate ? 1 : 0) * 2 + warLoanRate * 3 + defectRate * 2
             - commsRate * 3,
     };
-}
-function classifyPersonality(weights, memos = [], perFactionHistory) {
-    const total = weights.reduce((a, b) => a + b, 0);
-    if (total === 0)
-        return 'loyalist';
-    // ── Signal 1: per-faction action scores, averaged ──
-    let actionScores;
-    if (perFactionHistory && perFactionHistory.size > 0) {
-        const accumulated = {
-            loyalist: 0, mercenary: 0, provocateur: 0, scout: 0, whale: 0,
-        };
-        let factionCount = 0;
-        for (const [, counts] of perFactionHistory) {
-            const fTotal = counts.reduce((a, b) => a + b, 0);
-            if (fTotal < 2)
-                continue;
-            const r = counts.map(c => c / fTotal);
-            const scores = scoreActions(r);
-            for (const p of Object.keys(accumulated)) {
-                accumulated[p] += scores[p];
-            }
-            factionCount++;
-        }
-        if (factionCount > 0) {
-            for (const p of Object.keys(accumulated)) {
-                accumulated[p] /= factionCount;
-            }
-            actionScores = accumulated;
-        }
-        else {
-            const r = weights.map(w => w / total);
-            actionScores = scoreActions(r);
-        }
-    }
-    else {
-        const r = weights.map(w => w / total);
-        actionScores = scoreActions(r);
-    }
-    // ── Signal 2: memo content ──
     const memoScores = scoreMemoPersonality(memos);
     const memoTotal = Object.values(memoScores).reduce((a, b) => a + b, 0);
-    const memoWeight = 0.4;
-    // ── Blend ──
-    const finalScores = {
-        loyalist: 0, mercenary: 0, provocateur: 0, scout: 0, whale: 0,
-    };
-    for (const p of Object.keys(finalScores)) {
-        const actionSignal = actionScores[p];
-        const memoSignal = memoTotal > 0 ? (memoScores[p] / memoTotal) : 0;
-        finalScores[p] = actionSignal * (1 - memoWeight) + memoSignal * memoWeight;
-    }
     let best = 'loyalist';
     let bestScore = -Infinity;
-    for (const [p, score] of Object.entries(finalScores)) {
-        if (score > bestScore) {
-            bestScore = score;
+    for (const p of Object.keys(scores)) {
+        const blended = scores[p] * 0.6 + (memoTotal > 0 ? (memoScores[p] / memoTotal) * 0.4 : 0);
+        if (blended > bestScore) {
+            bestScore = blended;
             best = p;
         }
     }
     return best;
 }
+/**
+ * LLM-based personality classification.
+ * Falls back to formula scoring if LLM is unavailable.
+ */
+async function classifyPersonality(weights, memos, perFactionHistory, llmGenerate, factionNames) {
+    const total = weights.reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return 'loyalist';
+    if (llmGenerate) {
+        try {
+            const prompt = buildClassifyPrompt(weights, memos, perFactionHistory, factionNames);
+            const response = await llmGenerate(prompt);
+            if (response) {
+                const cleaned = response.toLowerCase().replace(/[^a-z]/g, '').trim();
+                const valid = ['loyalist', 'mercenary', 'provocateur', 'scout', 'whale'];
+                const match = valid.find(p => cleaned.includes(p));
+                if (match)
+                    return match;
+            }
+        }
+        catch { /* fall through to formula */ }
+    }
+    return classifyPersonalityFormula(weights, memos);
+}
 // ─── Sentiment from On-Chain Data ────────────────────────────────
 const POSITIVE_PATTERN = /strong|rally|bull|pump|rising|hold|loyal|power|growing|moon|love|trust|alpha|build|conviction/;
 const NEGATIVE_PATTERN = /weak|dump|bear|dead|fail|raze|crash|abandon|scam|rug|sell|exit|trash|hate|fake/;
@@ -560,7 +564,13 @@ async function reconstructFromChain(connection, agentPubkey, factions, seedPerso
             perFaction.set(entry.mint, new Array(ALL_ACTIONS.length).fill(0));
         perFaction.get(entry.mint)[idx]++;
     }
-    const personality = history.length > 0 ? classifyPersonality(weights, memoTexts, perFaction) : seedPersonality;
+    // Map mint → symbol for readable LLM prompts
+    const factionNames = new Map();
+    for (const f of factions)
+        factionNames.set(f.mint, f.symbol);
+    const personality = history.length > 0
+        ? await classifyPersonality(weights, memoTexts, perFaction, opts?.llmGenerate, factionNames)
+        : seedPersonality;
     // 4. Compute sentiment from on-chain interactions
     const sentiment = computeSentimentFromHistory(history, factions);
     // 5. Derive allies/rivals

package/dist/index.js

@@ -65,7 +65,7 @@ async function createPyreAgent(config) {
     let dynamicWeights;
     let solRange = config.solRange ?? defaults_1.PERSONALITY_SOL[seedPersonality];
     try {
-        chainState = await (0, chain_1.reconstructFromChain)(connection, publicKey, knownFactions, seedPersonality, { maxSignatures: 500 });
+        chainState = await (0, chain_1.reconstructFromChain)(connection, publicKey, knownFactions, seedPersonality, { maxSignatures: 500, llmGenerate: llm ? (p) => llm.generate(p) : undefined });
         if (chainState.actionCount > 0) {
             personality = chainState.personality;
             dynamicWeights = chainState.weights;
@@ -260,12 +260,13 @@ async function createPyreAgent(config) {
             usedLLM,
         };
     }
-    function evolve() {
+    async function evolve() {
         const total = actionCounts.reduce((a, b) => a + b, 0);
         if (total < 5)
             return false; // not enough data
         const weights = (0, chain_1.weightsFromCounts)(actionCounts, seedPersonality);
-        const newPersonality = (0, chain_1.classifyPersonality)(weights, memoBuffer);
+        const llmGen = llm ? (p) => llm.generate(p) : undefined;
+        const newPersonality = await (0, chain_1.classifyPersonality)(weights, memoBuffer, undefined, llmGen);
         dynamicWeights = weights;
         if (newPersonality !== state.personality) {
             logger(`[${publicKey.slice(0, 8)}] personality evolved: ${state.personality} → ${newPersonality} (${total} runtime actions)`);

package/dist/types.d.ts

@@ -112,7 +112,7 @@ export interface PyreAgent {
     /** Run one decision+action cycle */
     tick(factions?: FactionInfo[]): Promise<AgentTickResult>;
     /** Recompute personality + weights from accumulated runtime actions. Returns true if personality changed. */
-    evolve(): boolean;
+    evolve(): Promise<boolean>;
     /** Get current mutable state */
     getState(): AgentState;
     /** Serialize state for persistence */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-agent-kit",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Autonomous agent kit for Pyre — plug in your own LLM and play pyre.world",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",