Use any HTTP client.

curl https://gateway.limitfuse.com/v1/chat/completions \
  -H "Authorization: Bearer $LIMITFUSE_PROJECT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "limitfuse-default",
    "messages": [
      {"role": "user", "content": "Summarize the support case."}
    ],
    "max_completion_tokens": 500,
    "limitfuse": {
      "feature": "support-triage",
      "operation_id": "case-1842-summary",
      "logical_operation_id": "case-1842-summary",
      "attempt": 1
    }
  }'

const response = await fetch(
  "https://gateway.limitfuse.com/v1/chat/completions",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.LIMITFUSE_PROJECT_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "limitfuse-default",
      messages: [{ role: "user", content: "Classify this ticket." }],
      max_completion_tokens: 300,
      limitfuse: {
        feature: "support-triage",
        operation_id: crypto.randomUUID(),
        attempt: 1
      }
    })
  }
);

if (!response.ok) {
  const failure = await response.json();
  throw new Error(failure.error?.message ?? "Protected call failed");
}

const completion = await response.json();

curl https://gateway.limitfuse.com/v1/limitfuse/authorizations \
  -H "Authorization: Bearer $LIMITFUSE_PROJECT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "kind": "function",
    "feature": "invoice-sync",
    "run_id": "sync-2026-08-28-1842",
    "operation_id": "invoice-1842-attempt-1",
    "logical_operation_id": "invoice-1842",
    "estimated_max_cost_usd": 0.03,
    "attempt": 1,
    "ttl_seconds": 300
  }'

curl https://gateway.limitfuse.com/v1/limitfuse/authorizations/settle \
  -H "Authorization: Bearer $LIMITFUSE_PROJECT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "authorization": "lfa_...",
    "actual_cost_usd": 0.0184,
    "price_version": "provider-price-2026-08"
  }'

const authorityResponse = await fetch(
  "https://gateway.limitfuse.com/v1/limitfuse/authorizations",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.LIMITFUSE_PROJECT_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      kind: "function",
      feature: "invoice-sync",
      run_id: runId,
      operation_id: operationId,
      logical_operation_id: invoiceId,
      estimated_max_cost_usd: 0.03,
      attempt: 1
    })
  }
);

if (!authorityResponse.ok) {
  // Stop here. The provider or function has not run.
  throw new Error("LimitFuse denied the operation");
}

const { authorization } = await authorityResponse.json();

// Call the provider directly. Its key and payload never enter LimitFuse.
const result = await callYourProvider({ invoiceId });

await fetch(
  "https://gateway.limitfuse.com/v1/limitfuse/authorizations/settle",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.LIMITFUSE_PROJECT_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      authorization,
      actual_cost_usd: result.costUsd
    })
  }
);

const authority = await reserveLimitFuseAuthority();
const deadline = Date.parse(authority.execution_deadline_at);
const controller = new AbortController();
const timer = setTimeout(
  () => controller.abort(new Error("LimitFuse deadline exceeded")),
  Math.max(0, deadline - Date.now())
);
let started = false;

try {
  started = true; // Set immediately before external dispatch.
  const result = await callYourProvider({
    signal: controller.signal,
    maxTokens: 800,
    maxSteps: 6,
    timeoutMs: Math.max(1, deadline - Date.now())
  });
  await settleLimitFuse(authority.authorization, result.costUsd);
} catch (error) {
  if (!started) {
    await cancelLimitFuse(authority.authorization);
    throw error;
  }

  // A timeout after dispatch is uncertain. Never release authority here.
  const stopped = await cancelProviderJob({
    jobId,
    timeoutMs: 5_000
  }).catch(() => ({ confirmed: false }));

  if (stopped.confirmed && stopped.costUsd !== undefined) {
    await settleLimitFuse(authority.authorization, stopped.costUsd);
  } else {
    await enqueueProviderLogReconciliation(authority.operation_id);
  }
} finally {
  clearTimeout(timer);
}

import { LimitFuseClient } from "@sansavision/limitfuse";

const limitfuse = new LimitFuseClient({
  gatewayUrl: "https://gateway.limitfuse.com",
  projectKey: process.env.LIMITFUSE_PROJECT_KEY!
});

const run = await limitfuse.createRun({
  organizationId: process.env.LIMITFUSE_ORGANIZATION_ID!,
  projectId: process.env.LIMITFUSE_PROJECT_ID!,
  environment: "production",
  feature: "support-triage"
});

const response = await limitfuse.chatCompletions({
  model: "limitfuse-default",
  messages: [{ role: "user", content: "Summarize the support case." }],
  max_completion_tokens: 500
}, { envelope: run.envelope });

const outcome = await limitfuse.executeExternalSafely({
  kind: "function",
  feature: "invoice-sync",
  runId,
  operationId,
  logicalOperationId: invoiceId,
  estimatedMaxCostUsd: 0.03,
  attempt: 1,
  maxOutputTokens: 800
}, {
  timeoutMs: 45_000,
  execute: async ({ signal, markStarted }) => {
    markStarted();
    const result = await callYourProvider({ invoiceId, signal, maxSteps: 6 });
    return { value: result, actualCostUsd: result.costUsd };
  },
  terminate: async ({ signal }) => {
    const stopped = await cancelProviderJob(jobId, { signal });
    return stopped.confirmed
      ? { status: "confirmed", actualCostUsd: stopped.costUsd }
      : { status: "uncertain" };
  }
});

if (outcome.status === "uncertain") {
  await enqueueProviderLogReconciliation(outcome.authorization.operation_id);
}