@trazum/core 1.8.0

package/src/advisories.ts

@@ -0,0 +1,431 @@
+import { analyzeCachePrefix } from './cache.js';
+import { getMessages } from './i18n/index.js';
+import type { Locale } from './i18n/types.js';
+import { COMPLEX_SIGNALS, SIMPLE_SIGNALS } from './phrases.js';
+import { BUNDLED_CATALOGUE, effectivePricing, modelFrom, multipliersFor } from './pricing.js';
+import type { PricingCatalogue } from './pricing.js';
+import { formatUsd } from './savings.js';
+import { analyzeExamples, findContradictions, findMovableSchema,
+  findRestatedFormat } from './structure.js';
+import { estimateTokens } from './tokenizer.js';
+import type { Advisory, ModelPricing, TokenCounter, UsageProfile } from './types.js';
+
+function countSignals(haystack: string, signals: readonly string[]): number {
+  let count = 0;
+  for (const signal of signals) if (haystack.includes(signal)) count++;
+  return count;
+}
+
+/**
+ * Estimates the capability tier the prompt needs.
+ *
+ * This is a keyword-and-size heuristic, not a judgement about answer quality.
+ * Treat it as a hypothesis to validate with your own evaluations before
+ * moving down a tier in production.
+ */
+export function recommendTier(prompt: string, tokens: number): ModelPricing['tier'] {
+  const haystack = prompt.toLowerCase();
+  let score =
+    countSignals(haystack, COMPLEX_SIGNALS) * 2 - countSignals(haystack, SIMPLE_SIGNALS) * 2;
+
+  if (tokens > 4000) score += 2;
+  else if (tokens > 1500) score += 1;
+  else if (tokens < 300) score -= 1;
+
+  if (/```|~~~/.test(prompt)) score += 1;
+
+  if (score >= 3) return 'opus';
+  if (score >= 0) return 'sonnet';
+  return 'haiku';
+}
+
+const TIER_ORDER: Record<ModelPricing['tier'], number> = {
+  /**
+   * Below every real tier, so no tier is ever "less capable than unknown".
+   *
+   * The value carries the intent rather than the guard below carrying it alone.
+   * Set the other way — above everything — the comparison
+   * `TIER_ORDER[suggested] < TIER_ORDER['unknown']` is true for every prompt,
+   * and the only thing left standing between that and a recommendation is an
+   * unrelated provider filter. Mutation testing found exactly that: deleting
+   * the guard changed no test result, because a second accident was covering
+   * for it. Two accidents in a row is not a design.
+   */
+  unknown: Number.NEGATIVE_INFINITY,
+  haiku: 0,
+  sonnet: 1,
+  opus: 2,
+  frontier: 3,
+};
+
+/**
+ * Cheapest model of a capability tier, using today's effective input price.
+ *
+ * **Within the same provider**, which is a product decision rather than an
+ * implementation detail. Dropping from Opus to Sonnet is a one-line change;
+ * moving to another vendor is a different API, different behaviour and a
+ * migration. This advisory is already caveated as a keyword heuristic rather
+ * than a judgement about answer quality, and a keyword heuristic has no business
+ * recommending that somebody change supplier.
+ *
+ * A model with no provider recorded only matches others with none, so an overlay
+ * that adds a bare model cannot pull a switch out of thin air.
+ */
+function cheapestInTier(
+  tier: ModelPricing['tier'],
+  on: Date,
+  pricing: PricingCatalogue,
+  provider: string | undefined,
+): ModelPricing | undefined {
+  const candidates = pricing.models.filter(
+    (m) =>
+      m.tier === tier &&
+      m.provider === provider &&
+      // Not generally available: recommending a model the reader cannot call is
+      // worse than recommending nothing.
+      m.recommendable !== false,
+  );
+  if (candidates.length === 0) return undefined;
+  return candidates.reduce((best, m) =>
+    effectivePricing(m, on).inputPerMTok < effectivePricing(best, on).inputPerMTok ? m : best,
+  );
+}
+
+export interface AdvisoryOptions {
+  /** Reference date, used to decide whether a promotional price is live. */
+  on?: Date;
+  /** Token counter, so the cache-prefix analysis matches the caller's. */
+  count?: TokenCounter;
+  locale?: Locale;
+  /** Prices to work from. Defaults to the catalogue bundled with this release. */
+  pricing?: PricingCatalogue;
+}
+
+/** Builds the advisories that do not modify the prompt but do move the bill. */
+export function buildAdvisories(
+  optimizedPrompt: string,
+  tokensAfter: number,
+  usage: UsageProfile,
+  options: AdvisoryOptions = {},
+): Advisory[] {
+  const { on = new Date(), count = estimateTokens, locale, pricing = BUNDLED_CATALOGUE } = options;
+  const t = getMessages(locale);
+
+  const advisories: Advisory[] = [];
+  const model = modelFrom(pricing, usage.model);
+  const { inputPerMTok, outputPerMTok, promoApplied } = effectivePricing(model, on);
+  // Per model, not global. A cache read is ~10% of input on Anthropic and about
+  // half on OpenAI; one constant for both overstates an OpenAI caching saving
+  // fivefold, which is an invented saving rather than an imprecise one.
+  const rates = multipliersFor(model);
+  const batchFactor = usage.batchEligible ? (rates.batch ?? 1) : 1;
+
+  const monthlyInputUsd =
+    (tokensAfter / 1_000_000) * inputPerMTok * usage.callsPerMonth * batchFactor;
+  const monthlyOutputUsd =
+    (usage.avgOutputTokens / 1_000_000) * outputPerMTok * usage.callsPerMonth * batchFactor;
+
+  // --- Context window ---
+  if (tokensAfter > model.contextWindow) {
+    advisories.push({
+      id: 'context-overflow',
+      severity: 'warning',
+      ...t.advisories.contextOverflow({
+        tokens: tokensAfter,
+        modelName: model.displayName,
+        contextWindow: model.contextWindow,
+      }),
+      estimatedMonthlyUsd: null,
+    });
+  }
+
+  // --- Prompt caching ---
+  // Caching is a prefix match: in a template with placeholders, only what
+  // precedes the first placeholder is cached. Costing the whole prompt would
+  // be a lie the moment {{x}} takes a different value between calls.
+  const cache = analyzeCachePrefix(optimizedPrompt, count);
+  // A provider with no prompt caching gets no caching advice. Without this the
+  // zero minimum satisfies `0 >= 0` and Trazum offers a saving that cannot be
+  // bought at any price — the exact failure that moving the multipliers onto the
+  // model was meant to prevent, reintroduced one field along.
+  /**
+   * Three ways to have nothing useful to say about caching, and only one of
+   * them used to be handled.
+   *
+   * `none` is a fact: the provider does not cache, so advice would be a saving
+   * nobody can buy. `unknown` is the absence of a fact — a catalogue built from
+   * a live price feed knows what a model costs and not how it caches — and it
+   * has to decline for the opposite reason: not because the answer is no, but
+   * because nobody asked anyone. Guessing either way is a number in somebody's
+   * budget that came from nowhere.
+   */
+  const cachingKnown = model.caching !== 'none' && model.caching !== 'unknown' && model.cacheMinTokens !== null;
+
+  if (usage.callsPerMonth > 1 && cachingKnown) {
+    const prefixShare = tokensAfter > 0 ? cache.stablePrefixTokens / tokensAfter : 0;
+    const monthlyPrefixUsd = monthlyInputUsd * Math.min(1, prefixShare);
+    const hitRate = Math.min(Math.max(usage.cacheHitRate, 0), 1);
+    const factor = (1 - hitRate) * rates.cacheWrite5m + hitRate * rates.cacheRead;
+
+    const minTokens = model.cacheMinTokens ?? 0;
+
+    if (cache.stablePrefixTokens >= minTokens) {
+      const saving = monthlyPrefixUsd * (1 - factor);
+      if (saving > 0) {
+        advisories.push({
+          id: 'prompt-caching',
+          severity: 'opportunity',
+          ...t.advisories.promptCaching({
+            placeholder: cache.firstPlaceholder,
+            prefixTokens: cache.stablePrefixTokens,
+            totalTokens: tokensAfter,
+            minTokens,
+            modelName: model.displayName,
+            hitRatePct: Math.round(hitRate * 100),
+            readPct: Math.round(rates.cacheRead * 100),
+            writePct: Math.round(rates.cacheWrite5m * 100),
+            explicit: (model.caching ?? 'explicit') === 'explicit',
+          }),
+          estimatedMonthlyUsd: saving,
+        });
+      } else {
+        advisories.push({
+          id: 'prompt-caching-not-worth-it',
+          severity: 'info',
+          ...t.advisories.promptCachingNotWorthIt(),
+          estimatedMonthlyUsd: null,
+        });
+      }
+    } else {
+      advisories.push({
+        id: 'below-cache-minimum',
+        severity: 'info',
+        ...t.advisories.belowCacheMinimum({
+          modelName: model.displayName,
+          minTokens,
+          placeholder: cache.firstPlaceholder,
+          prefixTokens: cache.stablePrefixTokens,
+          totalTokens: tokensAfter,
+          mentionLowerMinimum: minTokens > 512,
+        }),
+        estimatedMonthlyUsd: null,
+      });
+    }
+
+    // Stable content placed AFTER the first placeholder: never cached today,
+    // but moving it in front would make it cacheable.
+    if (
+      cache.firstPlaceholder &&
+      cache.staticTokensAfter >= 200 &&
+      cache.staticTokensAfter >= tokensAfter * 0.3
+    ) {
+      const movableShare = tokensAfter > 0 ? cache.staticTokensAfter / tokensAfter : 0;
+      const saving = monthlyInputUsd * movableShare * Math.max(0, 1 - factor);
+      advisories.push({
+        id: 'cache-prefix-reorder',
+        severity: 'opportunity',
+        ...t.advisories.cachePrefixReorder({
+          staticTokensAfter: cache.staticTokensAfter,
+          sharePct: Math.round(movableShare * 100),
+          placeholder: cache.firstPlaceholder,
+        }),
+        estimatedMonthlyUsd: saving > 0 ? saving : null,
+      });
+    }
+  }
+
+  // --- Batch API ---
+  // `rates.batch === null` means the provider has no batch API at all, which is
+  // different from not having said: advising a discount that cannot be bought
+  // is worse than staying quiet.
+  if (!usage.batchEligible && usage.callsPerMonth > 1 && rates.batch !== null) {
+    const saving = (monthlyInputUsd + monthlyOutputUsd) * (1 - rates.batch);
+    advisories.push({
+      id: 'batch-api',
+      severity: 'opportunity',
+      ...t.advisories.batchApi(),
+      estimatedMonthlyUsd: saving,
+    });
+  }
+
+  // --- Recommended model ---
+  const suggestedTier = recommendTier(optimizedPrompt, tokensAfter);
+  /**
+   * A model whose capability nobody recorded is never told it is overpowered.
+   *
+   * Part of the condition rather than an early return, which is how the first
+   * version of this was wrong: `return advisories` here skipped every advisory
+   * *after* the model check — output-dominated, contradictory instructions —
+   * none of which has anything to do with what tier the model is. An unknown
+   * capability is a reason to say nothing about capability, not a reason to
+   * stop reading the prompt.
+   *
+   * **Deliberately redundant**, and the one surviving mutant in this change.
+   * `TIER_ORDER.unknown` is `-Infinity`, so the comparison is already false and
+   * deleting this clause changes no behaviour and no test. It stays because the
+   * two express the same rule in different places: an ordering that forgets it
+   * and a condition that forgets it both have to happen before a model of
+   * unrecorded capability is told it is overpowered.
+   */
+  if (model.tier !== 'unknown' && TIER_ORDER[suggestedTier] < TIER_ORDER[model.tier]) {
+    const candidate = cheapestInTier(suggestedTier, on, pricing, model.provider);
+    if (candidate) {
+      const candidatePricing = effectivePricing(candidate, on);
+      const candidateMonthly =
+        ((tokensAfter / 1_000_000) * candidatePricing.inputPerMTok +
+          (usage.avgOutputTokens / 1_000_000) * candidatePricing.outputPerMTok) *
+        usage.callsPerMonth *
+        (usage.batchEligible ? 0.5 : 1);
+      const saving = monthlyInputUsd + monthlyOutputUsd - candidateMonthly;
+      if (saving > 0) {
+        advisories.push({
+          id: 'model-downgrade',
+          severity: 'opportunity',
+          ...t.advisories.modelDowngrade({
+            modelName: model.displayName,
+            tier: suggestedTier,
+            candidateName: candidate.displayName,
+            currentUsd: formatUsd(monthlyInputUsd + monthlyOutputUsd),
+            candidateUsd: formatUsd(candidateMonthly),
+          }),
+          estimatedMonthlyUsd: saving,
+        });
+      }
+    }
+  }
+
+  // --- Where the money actually is ---
+  if (monthlyOutputUsd > monthlyInputUsd * 2 && usage.avgOutputTokens > 0) {
+    advisories.push({
+      id: 'output-dominated',
+      severity: 'info',
+      ...t.advisories.outputDominated({
+        outputUsd: formatUsd(monthlyOutputUsd),
+        inputUsd: formatUsd(monthlyInputUsd),
+      }),
+      estimatedMonthlyUsd: null,
+    });
+  }
+
+  // --- Instructions that fight each other ---
+  // Not a saving: a contradiction is a correctness problem that happens to
+  // cost tokens, so it carries no dollar figure and sorts on severity instead.
+  const contradictions = findContradictions(optimizedPrompt);
+  const worst = contradictions[0];
+  if (worst) {
+    advisories.push({
+      id: 'contradictory-instructions',
+      severity: 'warning',
+      ...t.advisories.contradictoryInstructions({
+        axis: t.contradictionAxes[worst.axis],
+        firstValue: t.contradictionValues[worst.a.value],
+        firstSnippet: worst.a.snippet,
+        secondValue: t.contradictionValues[worst.b.value],
+        secondSnippet: worst.b.snippet,
+        otherCount: contradictions.length - 1,
+      }),
+      estimatedMonthlyUsd: null,
+    });
+  }
+
+  // --- Few-shot examples that repeat each other ---
+  const examples = analyzeExamples(optimizedPrompt, count);
+  if (examples.redundant.length > 0 && examples.redundantTokens > 0) {
+    const saving =
+      tokensAfter > 0
+        ? monthlyInputUsd * Math.min(1, examples.redundantTokens / tokensAfter)
+        : 0;
+    const topSimilarity = Math.max(...examples.redundant.map((r) => r.similarity));
+    advisories.push({
+      id: 'redundant-examples',
+      severity: 'opportunity',
+      ...t.advisories.redundantExamples({
+        redundantCount: examples.redundant.length,
+        totalCount: examples.examples.length,
+        redundantTokens: examples.redundantTokens,
+        topSimilarityPct: Math.round(topSimilarity * 100),
+      }),
+      estimatedMonthlyUsd: saving > 0 ? saving : null,
+    });
+  }
+
+  // --- Output format written out twice ---
+  const restated = findRestatedFormat(optimizedPrompt, count);
+  const movable = findMovableSchema(optimizedPrompt, count);
+  if (movable) {
+    /**
+     * Priced from the tokens, which are real and reproducible, with the
+     * uncertainty in the text rather than in the figure.
+     *
+     * What Trazum knows is how many tokens the block holds; what it cannot know
+     * from here is whether the provider accepts a response schema. Withholding
+     * the figure for that reason would be the wrong trade — the number is right
+     * *if* the move is available, and the advisory says plainly that it does not
+     * check. The same posture as `model-downgrade`, which carries a figure and
+     * says out loud that it is a keyword heuristic.
+     */
+    const saving =
+      tokensAfter > 0 ? monthlyInputUsd * Math.min(1, movable.tokens / tokensAfter) : 0;
+    advisories.push({
+      id: 'movable-output-schema',
+      severity: 'opportunity',
+      ...t.advisories.movableSchema({
+        blocks: movable.blocks,
+        tokens: movable.tokens,
+        keyList: movable.keys.map((k) => `\`${k}\``).join(', '),
+        cue: movable.cue,
+      }),
+      estimatedMonthlyUsd: saving > 0 ? saving : null,
+    });
+  }
+
+  if (restated) {
+    const saving =
+      tokensAfter > 0
+        ? monthlyInputUsd * Math.min(1, restated.restatedTokens / tokensAfter)
+        : 0;
+    advisories.push({
+      id: 'restated-output-format',
+      severity: 'opportunity',
+      ...t.advisories.restatedOutputFormat({
+        restatedCount: restated.restatedKeys.length,
+        totalCount: restated.keys.length,
+        restatedTokens: restated.restatedTokens,
+        keyList: restated.restatedKeys.map((k) => `\`${k}\``).join(', '),
+      }),
+      estimatedMonthlyUsd: saving > 0 ? saving : null,
+    });
+  }
+
+  if (promoApplied && model.promo) {
+    advisories.push({
+      id: 'promo-pricing',
+      severity: 'warning',
+      ...t.advisories.promoPricing({
+        modelName: model.displayName,
+        promoInput: model.promo.inputPerMTok,
+        promoOutput: model.promo.outputPerMTok,
+        until: model.promo.until,
+        listInput: model.inputPerMTok,
+        listOutput: model.outputPerMTok,
+      }),
+      estimatedMonthlyUsd: null,
+    });
+  }
+
+  // Warnings first, then by money. Sorting purely on the dollar figure buried
+  // things that are wrong — an overflowing context window, two instructions
+  // that contradict each other — underneath a saving of a few dollars, because
+  // being wrong carries no price tag.
+  const SEVERITY_ORDER: Record<Advisory['severity'], number> = {
+    warning: 0,
+    opportunity: 1,
+    info: 2,
+  };
+
+  return advisories.sort(
+    (a, b) =>
+      SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
+      (b.estimatedMonthlyUsd ?? 0) - (a.estimatedMonthlyUsd ?? 0),
+  );
+}

package/src/aws-sigv4.ts

@@ -0,0 +1,174 @@
+/**
+ * AWS Signature Version 4, by hand.
+ *
+ * **Why by hand.** `@trazum/core` has zero runtime dependencies and a test that
+ * fails the build if one appears. That is a security property rather than a
+ * packaging preference: this library reads people's prompts, and every
+ * dependency is somebody else's code reading them too. The AWS SDK is roughly
+ * a hundred packages to sign one request.
+ *
+ * **WebCrypto, not `node:crypto`.** The browser-safe entry point cannot reach a
+ * Node builtin — `apps/web` bundles this library, and a single `node:` import
+ * anywhere in that graph fails the build. `crypto.subtle` exists in both, so
+ * signing works in a browser and in the CLI without a second implementation.
+ * Everything here is therefore async, which HMAC-SHA256 does not need to be and
+ * `crypto.subtle` insists on anyway.
+ *
+ * **What is not asserted, and it matters.** There is no AWS-published
+ * known-answer vector in the tests. This environment cannot reach the internet
+ * to fetch one and cannot reach AWS to try a real call, so the tests check the
+ * canonical strings this builds — which are derivable from the specification by
+ * reading — plus the cryptographic properties that any correct signer has. A
+ * systematically wrong canonicalisation that is wrong *consistently* would pass
+ * all of them. The first real request against Bedrock is the proof, and until
+ * somebody makes one this is careful code rather than verified code.
+ */
+
+const ALGORITHM = 'AWS4-HMAC-SHA256';
+
+const encoder = new TextEncoder();
+
+function hex(bytes: ArrayBuffer): string {
+  return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+async function sha256Hex(text: string): Promise<string> {
+  return hex(await crypto.subtle.digest('SHA-256', encoder.encode(text)));
+}
+
+async function hmac(key: ArrayBuffer | Uint8Array, message: string): Promise<ArrayBuffer> {
+  const imported = await crypto.subtle.importKey(
+    'raw',
+    key as ArrayBuffer,
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign'],
+  );
+  return crypto.subtle.sign('HMAC', imported, encoder.encode(message));
+}
+
+/**
+ * `20260810T140102Z` and `20260810`, from one instant.
+ *
+ * Both derive from the same `Date` rather than being formatted twice. The
+ * classic SigV4 bug is a request signed at 23:59:59.9 whose date stamp comes
+ * from the next day: the credential scope and the timestamp disagree by one
+ * day, AWS rejects it, and it happens roughly once per thousand requests at
+ * midnight UTC and never in a test.
+ */
+export function amzDates(now: Date): { amzDate: string; dateStamp: string } {
+  const amzDate = `${now.toISOString().replace(/[:-]|\.\d{3}/g, '')}`;
+  return { amzDate, dateStamp: amzDate.slice(0, 8) };
+}
+
+/**
+ * The signing key: four chained HMACs, each keyed by the last.
+ *
+ * The chain is what scopes a signature to one day, one region and one service,
+ * so a leaked signature is not a leaked credential. `AWS4` prefixes the secret
+ * and is part of the specification rather than decoration.
+ */
+export async function signingKey(
+  secretAccessKey: string,
+  dateStamp: string,
+  region: string,
+  service: string,
+): Promise<ArrayBuffer> {
+  const kDate = await hmac(encoder.encode(`AWS4${secretAccessKey}`), dateStamp);
+  const kRegion = await hmac(kDate, region);
+  const kService = await hmac(kRegion, service);
+  return hmac(kService, 'aws4_request');
+}
+
+export interface SignInput {
+  method: string;
+  /** Already-encoded path, e.g. `/model/anthropic.claude-v2/invoke`. */
+  path: string;
+  host: string;
+  region: string;
+  service: string;
+  body: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  /** Present for temporary credentials, and signed when it is. */
+  sessionToken?: string;
+  now: Date;
+}
+
+/**
+ * The headers a signed request carries.
+ *
+ * Returned rather than mutated onto a request, so this is a pure function of its
+ * input and a test can read every byte of what it produced.
+ */
+export interface SignedHeaders {
+  authorization: string;
+  'x-amz-date': string;
+  'x-amz-content-sha256': string;
+  'x-amz-security-token'?: string;
+}
+
+/**
+ * Builds the canonical request, exactly as the specification orders it.
+ *
+ * Exported for the tests, because this string is where a signer goes wrong.
+ * Every field is joined with a newline, headers are lowercased and sorted, and
+ * the trailing newline after the header block is required — omit it and every
+ * signature is wrong in a way whose only symptom is `403 SignatureDoesNotMatch`.
+ */
+export async function canonicalRequest(input: SignInput): Promise<{
+  canonical: string;
+  signedHeaderNames: string;
+  payloadHash: string;
+}> {
+  const { amzDate } = amzDates(input.now);
+  const payloadHash = await sha256Hex(input.body);
+
+  // `host` and the two `x-amz-` headers are what Bedrock requires signed. Sorted
+  // by name because the specification says sorted, not because it looks tidier.
+  const headers: Array<[string, string]> = [
+    ['host', input.host],
+    ['x-amz-content-sha256', payloadHash],
+    ['x-amz-date', amzDate],
+  ];
+  if (input.sessionToken) headers.push(['x-amz-security-token', input.sessionToken]);
+  headers.sort((a, b) => (a[0] < b[0] ? -1 : 1));
+
+  const canonicalHeaders = headers.map(([name, value]) => `${name}:${value.trim()}\n`).join('');
+  const signedHeaderNames = headers.map(([name]) => name).join(';');
+
+  const canonical = [
+    input.method,
+    input.path,
+    // No query string on any request this signs. Present and empty, because the
+    // field is positional: dropping it shifts everything below it up a line.
+    '',
+    canonicalHeaders,
+    signedHeaderNames,
+    payloadHash,
+  ].join('\n');
+
+  return { canonical, signedHeaderNames, payloadHash };
+}
+
+/** The full `Authorization` header value, and the headers that go with it. */
+export async function signRequest(input: SignInput): Promise<SignedHeaders> {
+  const { amzDate, dateStamp } = amzDates(input.now);
+  const { canonical, signedHeaderNames, payloadHash } = await canonicalRequest(input);
+
+  const scope = `${dateStamp}/${input.region}/${input.service}/aws4_request`;
+  const stringToSign = [ALGORITHM, amzDate, scope, await sha256Hex(canonical)].join('\n');
+
+  const key = await signingKey(input.secretAccessKey, dateStamp, input.region, input.service);
+  const signature = hex(await hmac(key, stringToSign));
+
+  const headers: SignedHeaders = {
+    authorization:
+      `${ALGORITHM} Credential=${input.accessKeyId}/${scope}, ` +
+      `SignedHeaders=${signedHeaderNames}, Signature=${signature}`,
+    'x-amz-date': amzDate,
+    'x-amz-content-sha256': payloadHash,
+  };
+  if (input.sessionToken) headers['x-amz-security-token'] = input.sessionToken;
+  return headers;
+}