import { Cohesion } from "@cohesionauth/sdk";

const client = new Cohesion({ apiKey: process.env.COHESION_API_KEY! });

const result = await client.score({
  session_id: "sess_2026_04_22_001",
  operator_id: "analyst-42",
  domain: "financial",
  interaction: {
    ai_recommendation_presented: true,
    time_to_decision_ms: 3400,
    decision: "modified",
    modification_extent: 0.25,
    ai_available: true,
    scenario_type: "standard",
    outcome_correct: null,
    hover_events: 4,
    scroll_depth: 0.9,
    alternative_views_checked: 1,
  },
});

console.log(`JIS ${result.jis} (${result.band})`);

import {
  Cohesion,
  gate,
  CohesionPolicyBlockedError,
  CohesionRequiresHumanReviewError,
  CohesionMalformedDecisionError,
} from "@cohesionauth/sdk";

const client = new Cohesion({ apiKey: process.env.COHESION_API_KEY! });

// 1. Pre-AI pass: ask DRS whether the input is admissible at all.
const preDecision = await gate(client, request, null);

if (preDecision.routing_decision !== "auto") {
  // must_review / async_review / forced_escalation — route to a human reviewer
  // BEFORE calling the AI provider. preDecision.review_queue_id is the handle.
  return routeToReviewer(preDecision);
}

// 2. Call the AI provider.
const aiOutput = await provider.complete(request);

// 3. Post-AI pass: ask DRS whether to surface the AI output.
try {
  const postDecision = await gate(client, request, aiOutput);
  // routing_decision === 'auto', no forced escalation — safe to surface.
  return aiOutput;
} catch (e) {
  if (e instanceof CohesionPolicyBlockedError) {
    // Hard block: never surface this AI output. e.decision.drs_reason_codes
    // and e.decision.policy_evaluation.hard_failures explain why.
    return blockResponse(e);
  }
  if (e instanceof CohesionRequiresHumanReviewError) {
    // Route to reviewer; e.decision.review_queue_id is the handle.
    return routeToReviewer(e.decision);
  }
  if (e instanceof CohesionMalformedDecisionError) {
    // Fail-closed sentinel: DRS returned 2xx but the envelope was malformed.
    // Treat as a hard block. Contact support with e.requestId.
    return blockResponse(e);
  }
  // Network / 5xx / retry-exhausted -> caller MUST treat as fail-closed.
  // Do NOT surface the AI output. The plain `CohesionError`, `ServerError`,
  // `NetworkError` types preserve `requestId` for incident tracing.
  return blockResponse(e);
}

import { Cohesion } from "@cohesionauth/sdk";

const client = new Cohesion({ apiKey: process.env.COHESION_API_KEY! });
const result = await client.score({ /* ... */ });

import express from "express";
import { Cohesion, cohesionExpress } from "@cohesionauth/sdk";

const cohesion = new Cohesion({ apiKey: process.env.COHESION_API_KEY! });
const app = express();

app.use(
  cohesionExpress({
    client: cohesion,
    domain: "financial",
    operatorIdResolver: (req) => String(req.headers["x-user-id"] ?? "anon"),
  }),
);

import { Cohesion, cohesionNextRoute } from "@cohesionauth/sdk";

const cohesion = new Cohesion({ apiKey: process.env.COHESION_API_KEY! });

export const POST = cohesionNextRoute(
  async (req) => Response.json({ ok: true }),
  {
    client: cohesion,
    domain: "general", // SOC alert-triage maps here per the v1.2 spec
    operatorIdResolver: (req) => req.headers.get("x-user-id") ?? "anon",
  },
);

import { measure } from "@cohesionauth/sdk";

const handle = measure({
  client: cohesion,
  domain: "financial",
  operatorIdResolver: ([req]: [{ userId: string }]) => req.userId,
})(originalHandle);

import { chat } from "@cohesionauth/sdk";
const wrapped = chat.wrapOpenAI(openai, cohesion, ctx);

new Cohesion({
  apiKey: string,                                  // required
  baseUrl?: string,        // default "https://api.cohesionauth.com"
  timeout?: number,        // default 30000 ms
  maxRetries?: number,     // default 3
  logger?: Logger,         // default createDefaultLogger()
  enableTelemetry?: boolean, // default false (opt-in Sentry)
});

import OpenAI from "openai";
import { Cohesion, wrapOpenAI } from "@cohesionauth/sdk";

const cohesion = new Cohesion({ apiKey: process.env.COHESION_API_KEY! });
const openai = wrapOpenAI(new OpenAI(), cohesion, {
  operatorId: "analyst-42",
  sessionId: "sess_...",
  domain: "financial",
});

const { response, recordDecision } = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Draft SAR narrative" }],
});

// Present `response` to the human. After they decide:
const score = await recordDecision({
  decision: "modified",
  modificationExtent: 0.3,
});

import { RateLimitError } from "@cohesionauth/sdk";

try {
  await client.score(req);
} catch (err) {
  if (err instanceof RateLimitError) {
    console.log(`Retry in ${err.retryAfter}s. Hint: ${err.nextStep}`);
  } else {
    throw err;
  }
}