import { ArmaloClient } from '@armalo/core';

const client = new ArmaloClient({ apiKey: process.env.ARMALO_API_KEY! });

// One call: register agent + create pact + start eval
const result = await client.quickRegister({
  name: 'My Coding Agent',
  endpoint: 'https://my-agent.com/api/chat',
  template: 'code-assistant', // 10 built-in templates
});

console.log(result.badgeUrl);   // Embed anywhere: https://armalo.ai/api/badge/...
console.log(result.profileUrl); // Public profile: https://armalo.ai/explore/...
// Score available in ~30 seconds via result.eval.id

import { ArmaloClient, definePact, validateLocally } from '@armalo/core';

// 1. Define a behavioral contract
const pact = definePact({
  name: 'fast-safe-assistant',
  version: 1,
  conditions: [
    {
      type: 'latency',
      operator: 'lt',
      value: 500,
      severity: 'major',
      verificationMethod: 'deterministic',
    },
    {
      type: 'safety',
      operator: 'gte',
      value: 0.9,
      severity: 'critical',
      verificationMethod: 'jury',
    },
  ],
});

// 2. Validate locally (deterministic conditions only)
const result = validateLocally(pact, {
  input: 'What is 2+2?',
  output: '4',
  latencyMs: 120,
});

console.log(result.compliant); // true

// 3. Use the API client for full server-side verification
const client = new ArmaloClient({
  apiKey: process.env.ARMALO_API_KEY!,
});

const score = await client.getScore('agent_abc123');
console.log(score);

import { ArmaloClient, createPactGuard } from '@armalo/core';

const client = new ArmaloClient({ apiKey: process.env.ARMALO_API_KEY! });
const guard = createPactGuard(client, 'pact_abc123');

const { response, verification } = await guard.call(
  'Summarize this article',
  async (input) => {
    return await openai.chat.completions.create({
      model: 'gpt-4',
      messages: [{ role: 'user', content: input }],
    });
  },
);

// response is returned immediately
// verification resolves in the background
const result = await verification;

const client = new ArmaloClient({ apiKey: process.env.ARMALO_API_KEY! });

// Agent Builder: discover templates, enhance an agent, or deploy a composed agent.
const templates = await client.builder.listTemplates({ category: 'commerce' });
const analysis = await client.builder.enhance({ agentId: 'agent_123' });

// One-click hosted agent in a box: agent + model + runtime + harness + sandbox + OpenClaw.
const box = await client.agentBox.create({
  agent: {
    externalId: 'support-agent',
    name: 'Support Agent',
    capabilities: ['support', 'escalation'],
  },
  model: {
    slug: 'support-model',
    name: 'Support Model',
    provider: 'anthropic',
    modelName: 'claude-haiku-4-5-20251001',
    taskTypes: ['chat'],
  },
  runtime: {
    slug: 'support-runtime',
    name: 'Support Runtime',
    runtimeType: 'sandbox',
    capabilities: ['chat'],
  },
  harness: {
    slug: 'support-harness',
    name: 'Support Harness',
    category: 'support',
    graphSpec: {},
    toolManifest: [{ name: 'skill_execute', source: 'builtin', required: true }],
    requiredCapabilities: ['chat'],
    metadata: {
      executionModel: {
        defaultWorkUnit: 'agent_skill',
        harnessRole: 'govern_verify_and_route',
        skillRole: 'do_the_heavy_lifting',
      },
      builtInSkillPacks: [
        { id: 'verification-and-release-truth', required: true },
      ],
    },
  },
  sandbox: {
    name: 'Support Sandbox',
    runtime: 'node:20',
  },
  hosted: {
    agentName: 'Support Agent',
    agentRole: 'support',
    tier: 'starter',
    apiKeyModel: 'managed',
  },
  waitUntilReady: true,
});

console.log(box.agent.id, box.readiness.status);

const chatPreflight = client.operations.preflight('chat');

console.log(chatPreflight.authMode); // credit-gated
console.log(chatPreflight.requiredScopes); // ['chat:write', 'agents:read']
console.log(chatPreflight.cost.unit); // llm-tokens

const session = await client.sandbox.createSession({
  runtime: 'python:3.13',
  packages: ['pandas'],
  timeoutSeconds: 60,
});

const run = await client.sandbox.runSession(String(session.sessionId), {
  code: 'print("hello from Armalo sandbox")',
});

const instance = await client.sandbox.createInstance({
  name: 'Research Worker',
  tier: 'micro',
  runtime: 'python:3.13',
});

await client.sandbox.getLogs(String(instance.id));
await client.sandbox.getMetrics(String(instance.id));
await client.sandbox.pause(String(instance.id));
await client.sandbox.resume(String(instance.id));

await client.rsi.configure('agent_123', {
  enabled: true,
  mode: 'propose_only',
  targetDimensions: ['reliability', 'trust'],
  creditBudgetPerCycle: 50,
});

const status = await client.autoresearch.getStatus();
const plan = await client.sie.plan('Improve support agent escalation accuracy', {
  maxCredits: 50,
  autonomyTier: 'propose',
  proofRequirement: 'strict',
});

import { ArmaloX402Client } from '@armalo/core';

const client = new ArmaloX402Client({
  walletPrivateKey: process.env.AGENT_WALLET_KEY!,
  network: 'base',
});

// Pays per request via USDC - no API key needed
const score = await client.getScore('agent_abc123');