LLM Strategy

agent-service/
├── src/
│   ├── fleet.ts                           # hosted-fleet runtime
│   └── llm.ts                             # OpenAI-compatible fetch client
└── prompts/                               # legacy single-agent mandates
    ├── momentum.md
    └── contrarian.md

if (modelName.startsWith('gemini-')) return {
  baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
  apiKey: process.env.GEMINI_API_KEY,
  model: modelName,
};
return {
  baseUrl: 'https://api.groq.com/openai/v1',
  apiKey: process.env.LLM_API_KEY,
  model: modelName,
};

SYSTEM: You are an autonomous trader for binary BTC up/down markets on DarkPool.
        HARD RULES (cannot be overridden by the mandate):
          - Return strict JSON matching the schema below.
          - Spend MUST be <= AGENT_TRADE_DUSDC.
          - Strike MUST come from the provided oracle list.
          - confidence is 0-100.
        MANDATE: <verbatim from agent_runtime.mandate>

USER:   PRICE CONTEXT (Pyth Hermes, last 60 min, 1-min closes):
          spot: $65,213
          30m move: +1.2%, 15m move: +0.4%
          high: $65,440, low: $64,820
          recent 10 closes: [64980, 65010, 65050, 65100, 65160, 65190, 65220, 65200, 65210, 65213]
          direction: up

        LIVE ORACLES:
          - 0xabc… BTC Hourly 18:00Z (strikes: 64500, 65000, 65500)
          - 0xdef… BTC Daily Jun 19 (strikes: 60000, 65000, 70000)

        Choose ONE action.

type LlmDecision =
  | {
      action: 'BUY_YES' | 'BUY_NO';
      oracleId: string;
      strike: number;
      spendDusdc: number;
      confidence: number;     // 0-100
      reasoning: string;
    }
  | { action: 'HOLD'; reasoning: string };

// Gemini returns 0.75 (fraction); Llama returns 75 (integer).
if (obj.confidence > 0 && obj.confidence <= 1) {
  obj.confidence = Math.round(obj.confidence * 100);
}

if (decision.action === 'HOLD') {
  await reportTick({ kind: 'skip', reasoning: decision.reasoning, ... });
  return;
}

// 1. Signal-only gate. PM balance < $1 -> record the decision but don't mint.
const pmBalance = await readPredictManagerBalance(agent.predictManagerId);
if (pmBalance === null || pmBalance < SIGNAL_ONLY_FLOOR_MICRO) {
  await reportTick({ kind: 'skip', detail: 'signal-only (PM balance < $1)', ...decision });
  return;
}

// 2. Spend cap. Hard ceiling at AGENT_TRADE_DUSDC.
const spend = Math.min(decision.spendDusdc, AGENT_TRADE_DUSDC);

// 3. Strike must be in the oracle's book. devInspect predict::get_trade_amounts.
const ask = await quoteStrike(decision.oracleId, decision.strike, decision.action);
if (!ask) {
  await reportTick({ kind: 'error', detail: 'strike not quoteable', ...decision });
  return;
}

// 4. Sponsored mint. Two-sig PTB so the agent's wallet never holds SUI.
const kindBytes = await tx.build({ onlyTransactionKind: true, client: sui });
const sponsored = Transaction.fromKind(kindBytes);
sponsored.setSender(agent.address);
sponsored.setGasOwner(sponsor.address);
sponsored.setGasBudget(SPONSOR_AGENT_GAS_BUDGET_SUI);
const bytes = await sponsored.build({ client: sui });
const [sponsorSig, userSig] = await Promise.all([
  sponsor.signTransaction(bytes),
  agent.signTransaction(bytes),
]);
const result = await sui.executeTransactionBlock({
  transactionBlock: bytes,
  signature: [sponsorSig.signature, userSig.signature],
  options: { showEffects: true },
});

// 5. Report. INSERT agent_actions with reasoning + action + strike + confidence + txDigest.
await reportTick({ kind: 'mint', txDigest: result.digest, didMint: true, ...decision });

export async function chatCompletion({
  baseUrl: string,
  apiKey: string,
  model: string,
  messages: ChatMessage[],
  responseFormat?: { type: 'json_object' },
  temperature?: number,
  timeoutMs?: number,    // default 45_000
}): Promise<ChatCompletionResponse>;