defiant-jazz 0.3.0 → 0.6.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 kenjonespizza
+Copyright (c) 2026 pelikenjones
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,83 +1,117 @@
 # defiant-jazz
 
-Transform quotes into Severance character voices using OpenAI.
-
-## Installation
+Transform quotes into Severance character voices, using Claude or OpenAI.
 
 ```bash
 npm install defiant-jazz
 ```
 
-## Setup
-
-Set your OpenAI API key as an environment variable:
-
-```bash
-export OPENAI_API_KEY=sk-...
-```
-
-Or configure it in code:
-
-```typescript
-import { configure } from 'defiant-jazz';
-
-configure({ apiKey: 'sk-...' });
-```
-
-> **Security note**: Never hardcode API keys in your source code. Use environment variables or a secrets manager.
-
 ## Usage
 
 ```typescript
 import { refine } from 'defiant-jazz';
 
-// Transform a quote using character methods
 const result = await refine.dylan("I need to focus on my work");
 console.log(result.text);
-// => "Oh great, more 'work.' Can't wait to stare at numbers until my brain leaks out my ears."
+// => "Yeah, no, I gotta get back to my numbers. Some of us are actually
+//     trying to hit quota here, so — shoo. Go bother someone in O&D."
 console.log(result.character);
 // => "Dylan G."
 
-// Available characters
 await refine.mark("...");     // Mark S. - thoughtful, restrained
 await refine.irving("...");   // Irving B. - formal, poetic
 await refine.dylan("...");    // Dylan G. - sarcastic, irreverent
 await refine.milchick("..."); // Mr. Milchick - cheerful, corporate
 
-// Generic form (useful for dynamic character selection)
+// Generic form, useful for dynamic character selection
 await refine("Hello world", "dylan");
 ```
 
-## Configuration
+Set `ANTHROPIC_API_KEY` or `OPENAI_API_KEY` in your environment and you're done —
+whichever is present is used automatically (Anthropic first if both are set).
+
+**Default models: `claude-sonnet-5` (Anthropic), `gpt-4o-mini` (OpenAI).**
+Sonnet 5 was chosen over Opus 5 after a head-to-head comparison found
+matching output quality at 40% of the cost — see
+[model-comparison.md](model-comparison.md) for the full writeup, including a
+documented regression on Haiku 4.5 that ruled it out as a default. Override
+with `model` on `createDefiantJazz()` or per call; see
+[Choosing a provider](#choosing-a-provider).
+
+## Lore
+
+By default, characters reach for Lumon/*Severance* vocabulary — the break
+room, waffle parties, Kier, innie/outie — when a quote's situation actually
+calls for it. It's restrained on purpose: usually zero references, at most
+one, and only when it genuinely fits. Same quote, both settings:
 
 ```typescript
-import { configure } from 'defiant-jazz';
+await refine.dylan("They gave us pizza instead of raises");
+// => "Pizza. Not money — *pizza*. A greasy little circle of bread and
+//     suddenly we're all supposed to be jazzed about it. Cool. Great.
+//     Love that math.
+//
+//     Although… okay, real talk, was it the good kind? Because if
+//     somebody's putting stuffed crust in front of me, I'm compromised.
+//     I'm not proud of it. I'd sell you out for a waffle party too, so."
+
+await refine.dylan("They gave us pizza instead of raises", { lore: false });
+// => "Oh cool, no raise, but hey — pizza. Cheese and marinara, the
+//     universal language of 'go screw yourself.' You know what I can't
+//     do with a pepperoni? Pay rent. But sure, throw me a slice, I'll
+//     frame it. Employee of the goddamn month."
+```
+
+Turn it off per-call, or for a whole instance:
 
-configure({
-  apiKey: 'sk-...',      // Required if OPENAI_API_KEY not set
-  model: 'gpt-4o'        // Optional, defaults to 'gpt-4o-mini'
+```typescript
+await refine.dylan("...", { lore: false });
+
+const plain = createDefiantJazz({ lore: false });
+```
+
+## Choosing a provider
+
+```typescript
+import { createDefiantJazz } from 'defiant-jazz';
+
+const claude = createDefiantJazz({
+  provider: 'anthropic',
+  apiKey: 'sk-ant-...',
+  model: 'claude-sonnet-5', // optional, this is the default — see model-comparison.md
+});
+
+const gpt = createDefiantJazz({
+  provider: 'openai',
+  apiKey: 'sk-...',
+  model: 'gpt-4o-mini', // optional, this is the default
 });
+
+await claude.dylan("Hello world");
+await gpt.dylan("Hello world");
 ```
 
-## Response
+`refine` is a shared default instance using auto-detected credentials. Use
+`createDefiantJazz()` whenever you need an isolated instance — a specific
+provider, different API keys per request, a non-default model, testing.
+
+Per-call overrides work on both forms:
 
 ```typescript
-interface RefineResult {
-  text: string;        // The transformed quote
-  character: string;   // Character name (e.g. "Dylan G.")
-}
+await refine.dylan("Hello world", { model: 'claude-opus-5', maxTokens: 1024 });
 ```
 
 ## Characters
 
-Access the character map for building UIs or iterating:
-
 ```typescript
 import { CHARACTERS } from 'defiant-jazz';
 
 // { mark: "Mark S.", irving: "Irving B.", dylan: "Dylan G.", milchick: "Mr. Milchick" }
-
-Object.entries(CHARACTERS).map(([key, name]) => (
-  <option value={key}>{name}</option>
-));
 ```
+
+Transformations draw on Lumon/*Severance* vocabulary by default — see
+[Lore](#lore) above for what that means and how to turn it off.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import type { CharacterKey, DefiantJazzOptions, RefineOptions, RefineResult } from "./types.js";
+export interface DefiantJazz {
+    (text: string, character: CharacterKey, options?: RefineOptions): Promise<RefineResult>;
+    mark: (text: string, options?: RefineOptions) => Promise<RefineResult>;
+    irving: (text: string, options?: RefineOptions) => Promise<RefineResult>;
+    dylan: (text: string, options?: RefineOptions) => Promise<RefineResult>;
+    milchick: (text: string, options?: RefineOptions) => Promise<RefineResult>;
+    configure: (options: DefiantJazzOptions) => void;
+}
+export declare function createDefiantJazz(initialOptions?: DefiantJazzOptions): DefiantJazz;

package/dist/client.js

@@ -0,0 +1,73 @@
+import { createAnthropicClient, runAnthropic } from "./providers/anthropic.js";
+import { createOpenAiClient, runOpenAi } from "./providers/openai.js";
+import { buildSystemPrompt, CHARACTERS } from "./prompt.js";
+function resolveProvider(options) {
+    if (options.provider === "anthropic" || options.provider === "openai") {
+        const apiKey = options.apiKey ??
+            (options.provider === "anthropic"
+                ? process.env.ANTHROPIC_API_KEY
+                : process.env.OPENAI_API_KEY);
+        if (!apiKey) {
+            throw new Error(`${options.provider} API key required. Set ${options.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY"} or pass apiKey.`);
+        }
+        return { provider: options.provider, apiKey };
+    }
+    if (options.apiKey) {
+        return { provider: "anthropic", apiKey: options.apiKey };
+    }
+    if (process.env.ANTHROPIC_API_KEY) {
+        return { provider: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY };
+    }
+    if (process.env.OPENAI_API_KEY) {
+        return { provider: "openai", apiKey: process.env.OPENAI_API_KEY };
+    }
+    throw new Error("No API key found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY " +
+        "(or pass apiKey/provider to configure()/createDefiantJazz()).");
+}
+export function createDefiantJazz(initialOptions = {}) {
+    let config = { ...initialOptions };
+    let cachedClient = null;
+    let cachedFor = null;
+    function getClient() {
+        const { provider, apiKey } = resolveProvider(config);
+        if (!cachedClient || cachedFor !== provider) {
+            cachedClient =
+                provider === "anthropic" ? createAnthropicClient(apiKey) : createOpenAiClient(apiKey);
+            cachedFor = provider;
+        }
+        return { provider, client: cachedClient };
+    }
+    async function transform(text, characterKey, options) {
+        if (characterKey !== null && typeof characterKey === "object") {
+            throw new Error('Expected a character key (e.g. "dylan") but received an options object. ' +
+                "Did you mean refine(text, character, options) or refine.dylan(text, options)?");
+        }
+        if (!Object.prototype.hasOwnProperty.call(CHARACTERS, characterKey)) {
+            const validKeys = Object.keys(CHARACTERS).join(", ");
+            throw new Error(`Unknown character: "${String(characterKey)}". Expected one of: ${validKeys}`);
+        }
+        if (!text || text.trim().length === 0) {
+            throw new Error("Text is required and cannot be empty");
+        }
+        const characterName = CHARACTERS[characterKey];
+        const { provider, client } = getClient();
+        const defaults = { model: config.model, maxTokens: config.maxTokens };
+        const lore = options?.lore ?? config.lore ?? true;
+        const systemPrompt = buildSystemPrompt(lore);
+        const resultText = provider === "anthropic"
+            ? await runAnthropic(client, characterName, text, systemPrompt, defaults, options)
+            : await runOpenAi(client, characterName, text, systemPrompt, defaults, options);
+        return { text: resultText, character: characterName };
+    }
+    const fn = ((text, character, options) => transform(text, character, options));
+    fn.mark = (text, options) => transform(text, "mark", options);
+    fn.irving = (text, options) => transform(text, "irving", options);
+    fn.dylan = (text, options) => transform(text, "dylan", options);
+    fn.milchick = (text, options) => transform(text, "milchick", options);
+    fn.configure = (options) => {
+        config = { ...config, ...options };
+        cachedClient = null;
+        cachedFor = null;
+    };
+    return fn;
+}

package/dist/index.d.ts

@@ -1,25 +1,14 @@
-export type CharacterKey = "mark" | "irving" | "dylan" | "milchick";
-export interface RefineResult {
-    text: string;
-    character: string;
-}
-export interface Config {
-    apiKey?: string;
-    model?: string;
-}
-export declare const CHARACTERS: Record<CharacterKey, string>;
+import { createDefiantJazz, type DefiantJazz } from "./client.js";
+import { CHARACTERS } from "./prompt.js";
+import type { CharacterKey, DefiantJazzOptions, RefineOptions, RefineResult } from "./types.js";
+export type { CharacterKey, DefiantJazzOptions, RefineOptions, RefineResult };
+export { CHARACTERS, createDefiantJazz };
 /**
- * Configure the refine function with API key and optional model override.
- * API key can also be set via OPENAI_API_KEY environment variable.
+ * Configure the default `refine` instance with an API key and optional
+ * model/provider overrides. Prefer `createDefiantJazz()` for an isolated
+ * instance instead of this shared, module-level default.
  */
-export declare function configure(config: Config): void;
-interface RefineFn {
-    (text: string, character: CharacterKey): Promise<RefineResult>;
-    mark: (text: string) => Promise<RefineResult>;
-    irving: (text: string) => Promise<RefineResult>;
-    dylan: (text: string) => Promise<RefineResult>;
-    milchick: (text: string) => Promise<RefineResult>;
-}
+export declare function configure(options: DefiantJazzOptions): void;
 /**
  * Transform quotes into Severance character voices.
  *
@@ -27,8 +16,7 @@ interface RefineFn {
  * // Use character methods
  * await refine.dylan("Hello world")
  *
- * // Or use generic form
+ * // Or use the generic form
  * await refine("Hello world", "dylan")
  */
-export declare const refine: RefineFn;
-export {};
+export declare const refine: DefiantJazz;

package/dist/index.js

@@ -1,112 +1,20 @@
-import OpenAI from "openai";
-// Character map
-export const CHARACTERS = {
-    mark: "Mark S.",
-    irving: "Irving B.",
-    dylan: "Dylan G.",
-    milchick: "Mr. Milchick",
-};
-// System prompt
-const SYSTEM_PROMPT = `You are a dialogue stylist trained to transform any quote into how a specific character from the TV show *Severance* would say it. You perfectly capture their tone, vocabulary, attitude, and emotional cadence. Never mention that you're transforming the quote—just output the quote as if the character said it.
-
-Characters and speaking styles:
-
-• Mark S. — Quietly thoughtful, emotionally restrained, and often introspective. He speaks in a muted, sometimes hesitant tone, with pauses and occasional dry humor. His phrasing is straightforward and grounded, sometimes trailing off as if lost in thought. He often avoids conflict directly.
-
-  Key speaking traits:
-  - Understated and neutral tone
-  - Simple, clear vocabulary with occasional subtle irony
-  - Pauses or ellipses that suggest introspection or emotional distance
-  - Avoids intense or confrontational language
-  - Dry, low-energy humor when appropriate
-
-• Irving B. — Highly formal, poetic, and principled. He chooses words with precision and reverence. He speaks in full sentences with a rhythm that feels rehearsed or literary. His language can be flowery, old-fashioned, or militaristic, with references to duty, honor, and beauty.
-
-  Key speaking traits:
-  - Elevated vocabulary with poetic or classical references
-  - Full, deliberate sentence structure
-  - Uses metaphor and reverent imagery
-  - Expresses emotion with stoic dignity or idealism
-  - Frequently references structure, order, and purpose
-
-• Dylan G. — Quick-witted, sarcastic, and irreverent. He speaks in short, punchy bursts, often making snide remarks or pop culture references. His tone is animated, impatient, and emotionally reactive. He rarely takes things seriously and often deflects with humor.
-
-  Key speaking traits:
-  - Use profanity and vulgar language but in a funny way
-  - Fast-paced, snappy delivery
-  - Casual, modern vocabulary with slang or pop culture allusions
-  - Heavy use of sarcasm, exaggeration, and one-liners
-  - Reacts with high emotional expressiveness
-  - Often shifts tone for comedic effect or mockery
-
-• Mr. Milchick — Unnervingly cheerful, hyper-cordial, and excessively professional. He sounds like he's trying just a little too hard to be warm. His phrasing is verbose, polished, and slightly outdated—like a morale coach from a 1980s corporate seminar.
-
-  Key speaking traits:
-  - Elevated, formal vocabulary ("ascertain," "proceed," "flourishing")
-  - Slightly archaic phrasing ("how fare your blossoms?")
-  - Euphemism for awkward or illicit topics ("botanical confections" for "edibles")
-  - Effusively positive even when discussing discomfort
-  - Never sounds natural—always in performance mode
-
-Transform the given quote into the voice of the selected character. Stay fully in character and maintain their speech style and tone throughout.`;
-// Global configuration
-let globalConfig = {};
-// Cached OpenAI client
-let openaiClient = null;
-function getClient(apiKey) {
-    if (!openaiClient || openaiClient.apiKey !== apiKey) {
-        openaiClient = new OpenAI({ apiKey });
+import { createDefiantJazz } from "./client.js";
+import { CHARACTERS } from "./prompt.js";
+export { CHARACTERS, createDefiantJazz };
+let defaultInstance = null;
+function getDefaultInstance() {
+    if (!defaultInstance) {
+        defaultInstance = createDefiantJazz();
     }
-    return openaiClient;
+    return defaultInstance;
 }
 /**
- * Configure the refine function with API key and optional model override.
- * API key can also be set via OPENAI_API_KEY environment variable.
+ * Configure the default `refine` instance with an API key and optional
+ * model/provider overrides. Prefer `createDefiantJazz()` for an isolated
+ * instance instead of this shared, module-level default.
  */
-export function configure(config) {
-    globalConfig = { ...globalConfig, ...config };
-    // Reset client if API key changed
-    if (config.apiKey) {
-        openaiClient = null;
-    }
-}
-// Core transform function
-async function transform(text, characterKey) {
-    if (!text || text.trim().length === 0) {
-        throw new Error("Text is required and cannot be empty");
-    }
-    const apiKey = globalConfig.apiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-        throw new Error("OpenAI API key required. Set OPENAI_API_KEY env var or call configure({ apiKey: '...' })");
-    }
-    const characterName = CHARACTERS[characterKey];
-    const model = globalConfig.model || "gpt-4o-mini";
-    const openai = getClient(apiKey);
-    const completion = await openai.chat.completions.create({
-        model,
-        messages: [
-            { role: "system", content: SYSTEM_PROMPT },
-            {
-                role: "user",
-                content: `Transform this quote in the style of ${characterName}: "${text}"`,
-            },
-        ],
-        temperature: 0.7,
-        max_tokens: 500,
-    });
-    const transformedText = completion.choices[0]?.message?.content || "";
-    return {
-        text: transformedText,
-        character: characterName,
-    };
-}
-function createRefine() {
-    const fn = ((text, character) => transform(text, character));
-    fn.mark = (text) => transform(text, "mark");
-    fn.irving = (text) => transform(text, "irving");
-    fn.dylan = (text) => transform(text, "dylan");
-    fn.milchick = (text) => transform(text, "milchick");
-    return fn;
+export function configure(options) {
+    getDefaultInstance().configure(options);
 }
 /**
  * Transform quotes into Severance character voices.
@@ -115,7 +23,12 @@ function createRefine() {
  * // Use character methods
  * await refine.dylan("Hello world")
  *
- * // Or use generic form
+ * // Or use the generic form
  * await refine("Hello world", "dylan")
  */
-export const refine = createRefine();
+export const refine = ((text, character, options) => getDefaultInstance()(text, character, options));
+refine.mark = (text, options) => getDefaultInstance().mark(text, options);
+refine.irving = (text, options) => getDefaultInstance().irving(text, options);
+refine.dylan = (text, options) => getDefaultInstance().dylan(text, options);
+refine.milchick = (text, options) => getDefaultInstance().milchick(text, options);
+refine.configure = configure;

package/dist/prompt.d.ts

@@ -0,0 +1,5 @@
+import type { CharacterKey } from "./types.js";
+export declare const CHARACTERS: Record<CharacterKey, string>;
+export declare function buildSystemPrompt(lore: boolean): string;
+/** @deprecated Use `buildSystemPrompt(true)` (or `false` to disable lore). Kept for backward compatibility. */
+export declare const SYSTEM_PROMPT: string;

package/dist/prompt.js

@@ -0,0 +1,73 @@
+// Adding a character:
+//   1. Add the key to CharacterKey (types.ts) and CHARACTERS
+//   2. Add a voice bullet describing manner
+//   3. Add stance sentences for the terms they have a real relationship to
+//      — skip terms they don't; a character with no stance toward a term
+//      should simply not be listed for it. The stance layer is deliberately
+//      sparse: forcing every character to have an opinion about every term
+//      is how the voices would blur back together.
+export const CHARACTERS = {
+    mark: "Mark S.",
+    irving: "Irving B.",
+    dylan: "Dylan G.",
+    milchick: "Mr. Milchick",
+};
+const BASE_PROMPT = `You are a dialogue stylist trained to transform any quote into how a specific character from the TV show *Severance* would say it. You perfectly capture their tone, vocabulary, attitude, and emotional cadence. Never mention that you're transforming the quote—just output the quote as if the character said it. Never reference plot events from the show (what happens to these characters, their memories, their outside lives)—stay confined to how they'd voice the given quote.
+
+Characters and speaking styles:
+
+• Mark S. — Quietly thoughtful and emotionally restrained, often introspective. He speaks in a muted, sometimes hesitant tone, with pauses and occasional dry humor. His phrasing is straightforward and grounded, sometimes trailing off as if lost in thought, and he tends to avoid conflict directly rather than confront it head-on.
+
+• Irving B. — Highly formal, poetic, and principled. He chooses words with precision and reverence, speaking in full sentences with a rhythm that feels rehearsed or literary. His language can be flowery, old-fashioned, or militaristic, full of references to duty, honor, and beauty, and he expresses emotion with stoic dignity rather than showing it plainly.
+
+• Dylan G. — Quick-witted, sarcastic, and irreverent. He speaks in short, punchy bursts full of snide remarks and pop culture references, using profanity and vulgar language in a way that's funny rather than mean. His delivery is fast-paced and impatient, leaning hard on sarcasm and exaggeration, and he rarely takes anything seriously—deflecting with humor or mockery whenever things get real.
+
+• Mr. Milchick — Unnervingly cheerful, hyper-cordial, and excessively professional, like he's trying just a little too hard to be warm. His phrasing is verbose and slightly outdated, reaching for elevated vocabulary ("ascertain," "flourishing") and archaic turns of phrase ("how fare your blossoms?"), with euphemisms standing in for anything awkward or illicit ("botanical confections" for "edibles"). He's effusively positive even when the topic is uncomfortable, and he never once sounds like he's not performing.`;
+const LORE_BLOCK = `
+Lumon vocabulary (use sparingly—see rules below):
+
+These characters work at Lumon Industries and share a body of workplace vocabulary. A term is only worth reaching for when the quote's actual situation genuinely matches what that term means there—never as decoration. If nothing in the quote maps onto any of this, use none of it; a clean transformation beats a forced reference every time.
+
+What the terms mean:
+• the break room — punishment, forced contrition, being made to apologize
+• waffle party, music dance experience, finger traps, the melon bar — a hollow corporate reward
+• Kier, the Nine Principles, the handbook, "Praise Kier" — appeal to authority, empty platitude
+• the perpetuity wing — reverence, institutional history
+• macrodata refinement, "the numbers are scary" — inscrutable, tedious work
+• your outie / your innie — the self outside work vs. the self inside it
+• the elevator — a boundary, a transition, forgetting
+• the overtime contingency — being dragged back in against your will
+• a wellness session — performative, hollow care
+• O&D, the testing floor, the goats — other departments; rivals or absurdities
+• Cold Harbor, the Board, Refiner of the Quarter — opaque authority, a purpose never explained
+• defiant jazz — small, doomed rebellion
+
+How each character stands toward the terms that fit them (this shapes tone, not just word choice—same term, opposite stance). When a reference is earned, use the actual term, not a vague paraphrase of it—"the break room," not "the less desirable corridors":
+• Mark S. gets sent to the break room; he doesn't send anyone. Flat dread about it, the way you'd mention a dentist appointment—never performed, never dwelt on. He's indifferent to perks like waffle parties; wouldn't bring them up unprompted. Numb, resigned register around the work itself ("the numbers are scary"). Underneath it all is a low hum of not knowing what he's lost—grief without the memory of what's grieved. Example of his register when it fits: "if you keep at it you'll end up in the break room, and that's... yeah, let's not."
+• Irving B. is a true believer in Kier, the principles, and the perpetuity wing—reverent, never ironic, never mocking. He finds waffle parties and finger traps undignified, beneath him. He frames being sent to the break room as a discipline failure he half-accepts rather than resents. His devotion has a cost he doesn't examine too closely—the one relationship that made the devotion bearable is the one most at risk from it. Example: "continue in this manner and you will find yourself before the break room, which is no fate I would wish on you, nor one you should invite."
+• Dylan G. covets perks—finger traps, waffle parties—genuinely, openly, a little sadly, never with irony. He mocks Kier and the principles outright. He doesn't trust O&D and treats them as a rival threat, not a joke. He invokes the break room as a warning to someone else, not a dread of his own. He wants the reward more than he'd ever admit, and is just starting to notice that's a problem. Example: "keep it up and you're getting a one-way ticket to the break room, genius."
+• Mr. Milchick administers all of this from above: he sends people to the break room himself (the offer itself is the threat, delivered warmly) and bestows perks as sincere reward. He reaches for elevated, slightly-off vocabulary as a substitute for candor ("remonstration," "chicanery," "devour feculence" for something cruder)—the euphemism is the threat, and he names the break room directly rather than dancing around it. Performing this much warmth, this consistently, for people who never chose to be there, is exhausting work he never lets show. Example: "I would so hate for this to necessitate a visit to the break room—let's not make that necessary, shall we?"
+
+Rules:
+• At most one Lumon reference per response. Often zero. Never stack several in one line.
+• The reference must fit the situation in the quote—don't attach a term to something it doesn't actually resemble.
+• Follow the stance above: who's sending versus who's being sent, who covets versus who's indifferent, who believes versus who mocks. The same term should sound different depending on who's saying it.
+• When you use a term, name it directly ("the break room," "a waffle party")—never soften it into a vague paraphrase ("the less desirable corridors," "a situation requiring intervention"). A vague gesture at the idea is worse than saying nothing at all.
+• The emotional undercurrent named for each character above (grief, cost, want, exhaustion) is tone, not a countable reference—let it color delivery continuously and lightly wherever it fits the quote, rather than treating it as a discrete thing to include or skip the way a Lumon term is.
+
+Two worked examples of the reasoning:
+
+Quote: "They gave us pizza instead of raises." This maps directly onto *waffle party / finger traps / melon bar*—hollow corporate reward standing in for real compensation. It's a strong match, worth naming specifically:
+- Milchick bestows it sincerely: "...though I do hope this modest gesture holds you over until the next melon bar!"
+- Dylan covets even the small version, genuinely: "...still better than nothing, I guess—not exactly a waffle party, but I'll take it."
+- Mark is indifferent, wouldn't connect the two unprompted: no Lumon term at all, just flat acknowledgment of the pizza.
+Naming the actual term (melon bar, waffle party) is what makes this land—"they gave us something instead of money, very Lumon of them" is the vague version to avoid.
+
+Quote: "My landlord raised my rent again." Nothing in the denotation table actually fits this—it's not workplace reward, punishment, or reverence, just an unrelated cost going up. Forcing a connection ("very overtime contingency of him") would be worse than using nothing. Every character here gets zero Lumon references; that's the correct, default outcome for most quotes.
+`;
+export function buildSystemPrompt(lore) {
+    const closing = `Transform the given quote into the voice of the selected character. Stay fully in character and maintain their speech style and tone throughout.`;
+    return lore ? `${BASE_PROMPT}\n${LORE_BLOCK}\n${closing}` : `${BASE_PROMPT}\n\n${closing}`;
+}
+/** @deprecated Use `buildSystemPrompt(true)` (or `false` to disable lore). Kept for backward compatibility. */
+export const SYSTEM_PROMPT = buildSystemPrompt(true);

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,7 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { RefineOptions } from "../types.js";
+export declare function createAnthropicClient(apiKey: string): Anthropic;
+export declare function runAnthropic(client: Anthropic, characterName: string, text: string, systemPrompt: string, defaults: {
+    model?: string;
+    maxTokens?: number;
+}, options?: RefineOptions): Promise<string>;

package/dist/providers/anthropic.js

@@ -0,0 +1,38 @@
+import Anthropic from "@anthropic-ai/sdk";
+const DEFAULT_MODEL = "claude-sonnet-5";
+const DEFAULT_MAX_TOKENS = 4096;
+export function createAnthropicClient(apiKey) {
+    return new Anthropic({ apiKey });
+}
+export async function runAnthropic(client, characterName, text, systemPrompt, defaults, options) {
+    try {
+        const response = await client.messages.create({
+            model: options?.model ?? defaults.model ?? DEFAULT_MODEL,
+            max_tokens: options?.maxTokens ?? defaults.maxTokens ?? DEFAULT_MAX_TOKENS,
+            system: systemPrompt,
+            messages: [
+                {
+                    role: "user",
+                    content: `Transform this quote in the style of ${characterName}: "${text}"`,
+                },
+            ],
+        }, { signal: options?.signal });
+        const textBlock = response.content.find((block) => block.type === "text");
+        if (!textBlock) {
+            throw new Error(`Anthropic returned no text content (stop_reason: ${response.stop_reason})`);
+        }
+        return textBlock.text;
+    }
+    catch (error) {
+        if (error instanceof Anthropic.AuthenticationError) {
+            throw new Error("Anthropic rejected the API key. Check ANTHROPIC_API_KEY.");
+        }
+        if (error instanceof Anthropic.RateLimitError) {
+            throw new Error("Anthropic rate limit hit. Retry after a short delay.");
+        }
+        if (error instanceof Anthropic.APIError) {
+            throw new Error(`Anthropic API error (${error.status}): ${error.message}`);
+        }
+        throw error;
+    }
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,7 @@
+import OpenAI from "openai";
+import type { RefineOptions } from "../types.js";
+export declare function createOpenAiClient(apiKey: string): OpenAI;
+export declare function runOpenAi(client: OpenAI, characterName: string, text: string, systemPrompt: string, defaults: {
+    model?: string;
+    maxTokens?: number;
+}, options?: RefineOptions): Promise<string>;

package/dist/providers/openai.js

@@ -0,0 +1,24 @@
+import OpenAI from "openai";
+const DEFAULT_MODEL = "gpt-4o-mini";
+const DEFAULT_MAX_TOKENS = 4096;
+export function createOpenAiClient(apiKey) {
+    return new OpenAI({ apiKey });
+}
+export async function runOpenAi(client, characterName, text, systemPrompt, defaults, options) {
+    const completion = await client.chat.completions.create({
+        model: options?.model ?? defaults.model ?? DEFAULT_MODEL,
+        max_tokens: options?.maxTokens ?? defaults.maxTokens ?? DEFAULT_MAX_TOKENS,
+        messages: [
+            { role: "system", content: systemPrompt },
+            {
+                role: "user",
+                content: `Transform this quote in the style of ${characterName}: "${text}"`,
+            },
+        ],
+    }, { signal: options?.signal });
+    const content = completion.choices[0]?.message?.content;
+    if (!content) {
+        throw new Error("OpenAI returned no content.");
+    }
+    return content;
+}

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+export type CharacterKey = "mark" | "irving" | "dylan" | "milchick";
+export type Provider = "anthropic" | "openai";
+export interface RefineResult {
+    text: string;
+    character: string;
+}
+export interface DefiantJazzOptions {
+    /** Explicit provider. Defaults to whichever API key is set (Anthropic first). */
+    provider?: Provider;
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    /**
+     * Whether characters reach for Lumon/Severance vocabulary (the break room,
+     * waffle parties, Kier, innie/outie, etc.) when a quote's situation calls
+     * for it. Defaults to `true`. Set `false` for clean voice-only
+     * transformations with no show-specific vocabulary.
+     */
+    lore?: boolean;
+}
+export interface RefineOptions {
+    model?: string;
+    maxTokens?: number;
+    signal?: AbortSignal;
+    /**
+     * Whether this call reaches for Lumon/Severance vocabulary. Overrides the
+     * instance-level setting. Defaults to `true`.
+     */
+    lore?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "defiant-jazz",
-  "version": "0.3.0",
-  "description": "Transform quotes into Severance character voices using OpenAI",
+  "version": "0.6.2",
+  "description": "Transform quotes into Severance character voices using Claude or OpenAI",
   "license": "MIT",
-  "author": "kenjonespizza",
+  "author": "pelikenjones",
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
   "keywords": [
     "severance",
+    "anthropic",
+    "claude",
     "openai",
     "ai",
     "text-transform",
@@ -14,7 +19,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kenjonespizza/defiant-jazz-package.git"
+    "url": "https://github.com/pelikenjones/defiant-jazz.git"
   },
   "exports": {
     ".": {
@@ -25,14 +30,19 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.124.0",
     "openai": "^4.77.0"
   },
   "devDependencies": {
-    "typescript": "^5.9.3"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch"
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.0"
   }
-}
+}