import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:4100/v1",
  apiKey: process.env.PUNK_API_KEY ?? "punk-local",
  defaultHeaders: { "X-Punk-App": "my-app" },
});

import { Punk } from "@punktechnologies/sdk";

const punk = new Punk({ app: "my-app", agent: "my-bot" });
const result = await punk.chat({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Classify this ticket: refund request" }],
});
console.log(result.content, result.route, result.runId);
// route is "live" on the first call; repeats become "exact_cache" and,
// once learned and proven, "artifact".

const punk = new Punk({
  baseUrl: "http://localhost:4100", // default
  apiKey: process.env.PUNK_API_KEY, // only if the gateway requires bearer auth
  app: "support-triage",            // X-Punk-App
  agent: "triage-bot",              // X-Punk-Agent
  subject: "user-123",              // X-Punk-Subject (pseudonymous end user)
});

const r = await punk.chat({
  model: "gpt-4o",
  messages: [{ role: "user", content: "hello" }],
  temperature: 0,
});
r.content; // assistant text
r.runId;   // from the x-punk-run-id response header — use it for tracing/feedback
r.route;   // "live" | "exact_cache" | "artifact" | ... (x-punk-route header)
r.raw;     // the full OpenAI-shaped response body

import { Punk, punkChorusChat } from "@punktechnologies/sdk";

const punk = new Punk({ app: "support", agent: "chorus-client" });

const r = await punk.chat(punkChorusChat({
  messages: [{ role: "user", content: "Build a claim-graph answer with a receipt." }],
  budget_limit_usd: 0.25,
  latency_mode: "balanced",
  quality_mode: "maximum_quality",
  policy_profile: "regulated-support",
  receipt_mode: "full",
  circuit_mode: "learn",
  shadow_mode: true,
  chorus: { requestId: "req_123", workflowId: "wf_support" },
}));

const receipt = await punk.receipt(r.runId); // GET /api/v1/receipts/:id
// Current gateways may expose the same receipt-style material as an evidence packet:
const packet = await punk.evidencePacket(r.runId); // GET /api/v1/runs/:id/evidence-packet

const lookupAccount = punk.traceTool({
  name: "crm.lookupAccount",
  sideEffectLevel: 1, // read-only external
  ttlSeconds: 300,    // level <= 1 + TTL => tool-result cache participation
  execute: async (args: { accountId: string }) => crm.get(args.accountId),
});

// Pass the runId from the chat that triggered the tool:
const account = await lookupAccount({ accountId: "acct_42" }, { runId: r.runId });

await punk.feedback(r.runId, 1);                       // thumbs up
await punk.feedback(r.runId, -1, "should be: billing"); // correction

const page = await punk.fetchSom("https://example.com/pricing");
page.som;                 // regions/elements with stable ids
page.context;             // compact text ready for a prompt
page.tokensSavedEstimate; // raw-HTML tokens you didn't pay for
page.cached;              // second fetch of the same URL hits the SOM cache
page.diff;                // semantic diff vs. the previous snapshot, when bypassing cache

const { sessionId, som, context } = await punk.web.openSession("https://example.com");

// click a link by its SOM element id (e_…) — navigates and recompiles
const link = som.regions.flatMap((r) => r.elements).find((e) => e.role === "link");
const r1 = await punk.web.act(sessionId, { action: "click", target: link.id });
r1.result.navigated; // true
r1.diff;             // what changed, semantically weighted

// fill and submit a form (target a field for type/select, the r_form region for submit)
await punk.web.act(sessionId, { action: "type", target: "e_abc123", value: "k@example.com" });
await punk.web.act(sessionId, { action: "select", target: "e_def456", value: "pro" });
const submit = await punk.web.act(sessionId, { action: "submit", target: "r_form" });
submit.result.posted; // serialized fields sent by the form submission

await punk.web.closeSession(sessionId); // idle sessions auto-close after 5 minutes

await punk.savings();          // SavingsSummary: runs, cost, saved USD/ms, hit rates
await punk.patterns();         // discovered patterns and their lifecycle state
await punk.artifacts();        // synthesized artifacts with confidence + evidence counts
await punk.artifactDetail(id); // artifact + replay/shadow evaluations + source pattern
await punk.runDetail(id);      // run + full trace events + side-effect records
await punk.receipt(id);        // Chorus receipt for a run
await punk.evidencePacket(id); // support/security evidence packet for a run
await punk.cacheStats();       // per-tier entries and hits

const report = await punk.learningTick(); // force a learning pass (it also runs on a timer)
const artifact = await punk.promoteArtifact(id); // operator approval after replay+shadow proof

await punk.trace(runId, "tool.completed", { name: "x", result });  // append a trace event
await punk.ingestPrompt("claude-code", prompt);                    // side-load an observed prompt
await punk.toolCacheCheck("crm.lookupAccount", args);              // manual cache check (degrades to miss)
await punk.toolCacheStore("crm.lookupAccount", args, result, 300); // manual store (failures swallowed)