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

const punk = new Punk({ app: "my-app", agent: "my-bot", subject: "user-123" });

const client = new OpenAI(punk.openAIConfig());

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

const result = await punk.gateway.chat({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Classify this ticket: refund request" }],
});
console.log(result.content, result.route, result.runId, result.usage);
// route is usually "live" on the first call; eligible repeats can route
// through "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)
});

new OpenAI(punk.openAIConfig());
new Anthropic(punk.anthropicConfig());

const aiSdkProvider = createOpenAICompatible(
  punk.vercelOpenAICompatibleConfig({ name: "punk" })
);

const model = new ChatOpenAI({
  model: "gpt-4o",
  ...punk.langChainConfig()
});

import { createPunkOpenAIConfig } from "@punktechnologies/sdk/openai";
import { createPunkAnthropicConfig } from "@punktechnologies/sdk/anthropic";
import { createPunkVercelAIConfig } from "@punktechnologies/sdk/vercel-ai";
import { createPunkLangChainConfig } from "@punktechnologies/sdk/langchain";
import { createPunkOpenRouterConfig, openRouterModel } from "@punktechnologies/sdk/openrouter";

new OpenAI(createPunkOpenAIConfig({ app: "support", agent: "triage" }));
new Anthropic(createPunkAnthropicConfig({ app: "support", agent: "triage" }));

const model = openRouterModel("google/gemini-2.5-flash");

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.usage;   // normalized input/output/total token counts when present
r.model;   // response model when present
r.provider;// response provider when present
r.raw;     // the full OpenAI-shaped response body

for await (const chunk of punk.streamChat({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Stream a support reply." }]
})) {
  if (chunk.type === "delta") process.stdout.write(chunk.content);
}

const msg = await punk.anthropic.messages({
  model: "claude-sonnet-4-6",
  max_tokens: 256,
  messages: [{ role: "user", content: "What is a deterministic artifact?" }]
});

msg.content;       // text blocks joined together
msg.contentBlocks; // original Anthropic content blocks
msg.runId;
msg.route;
msg.usage;

for await (const chunk of punk.streamMessages({
  model: "claude-sonnet-4-6",
  max_tokens: 256,
  messages: [{ role: "user", content: "Stream a haiku about caching." }]
})) {
  if (chunk.type === "delta") process.stdout.write(chunk.content);
}

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),
});

await punk.withRun(r, async () => {
  const account = await lookupAccount({ accountId: "acct_42" });
});

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.explain(id);        // routeExplanation only
await punk.savingsForRun(id);  // per-run cost/savings counters
await punk.sideEffectsForRun(id);
await punk.waitForRun(id);     // poll until completed/failed/blocked
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)