opennote-cli 1.3.0 → 1.4.0

package/src/midi.ts

@@ -1,218 +0,0 @@
-import readline from 'node:readline';
-import { createInterface } from 'node:readline/promises';
-import type { MetronomeMode, NoteEvent } from './arrangement';
-import type { InstrumentProfile } from './instrument';
-import type { GeneratedNote } from './types';
-
-export type MidiNoteOn = {
-  pitch: number;
-  velocity: number;
-};
-
-type SeedOptions = {
-  baseOctave?: number;
-};
-
-type PlaybackOptions = {
-  beep?: boolean;
-  instrument?: InstrumentProfile;
-  metronome?: MetronomeMode;
-  bpm?: number;
-};
-
-const SCALE_OFFSETS = [0, 2, 4, 5, 7, 9, 11, 12];
-const SHIFT_MAP: Record<string, number> = {
-  '!': 1,
-  '@': 2,
-  '#': 3,
-  '$': 4,
-  '%': 5,
-  '^': 6,
-  '&': 7,
-  '*': 8,
-};
-const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
-
-const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-};
-
-function fgHex(hex: string): string {
-  const clean = hex.replace('#', '');
-  const r = Number.parseInt(clean.slice(0, 2), 16);
-  const g = Number.parseInt(clean.slice(2, 4), 16);
-  const b = Number.parseInt(clean.slice(4, 6), 16);
-  return `\x1b[38;2;${r};${g};${b}m`;
-}
-
-const palette = {
-  primary: fgHex('#d199ff'),
-  soft: fgHex('#ecebff'),
-};
-
-function color(text: string, code: string): string {
-  return `${code}${text}${c.reset}`;
-}
-
-function pitchToName(pitch: number): string {
-  const octave = Math.floor(pitch / 12) - 1;
-  return `${NOTE_NAMES[pitch % 12]}${octave}`;
-}
-
-function numberToPitch(numberKey: number, octave: number, sharp: boolean): number {
-  const base = 12 * (octave + 1) + SCALE_OFFSETS[numberKey - 1];
-  return Math.max(0, Math.min(127, base + (sharp ? 1 : 0)));
-}
-
-async function lineFallbackSeed(baseOctave: number): Promise<MidiNoteOn> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const raw = await rl.question(
-      'Seed key fallback (1-8, or !@#$%^&* for sharps, +/- octave not supported here): ',
-    );
-    const str = raw.trim();
-    const fromShiftSymbol = SHIFT_MAP[str];
-    const fromDigit = /^[1-8]$/.test(str) ? Number.parseInt(str, 10) : NaN;
-    const degree = Number.isFinite(fromShiftSymbol)
-      ? fromShiftSymbol
-      : Number.isFinite(fromDigit)
-        ? fromDigit
-        : 1;
-    const sharp = Boolean(fromShiftSymbol);
-    const pitch = numberToPitch(degree, baseOctave, sharp);
-    console.log(`Selected seed: ${pitchToName(pitch)} (${pitch})`);
-    return { pitch, velocity: 100 };
-  } finally {
-    rl.close();
-  }
-}
-
-// Test-mode keyboard input:
-// 1-8 = scale degrees, Shift+1-8 = sharps, +/- changes octave.
-export async function waitForSeedNote(options: SeedOptions = {}): Promise<MidiNoteOn> {
-  let octave = options.baseOctave ?? 4;
-
-  console.log(`\n${color('Keyboard seed mode', `${c.bold}${palette.primary}`)}`);
-  console.log(color('Press 1-8 to choose note, Shift+1-8 for sharp, +/- for octave, q to cancel.', palette.soft));
-  console.log(color('Click this terminal window first if key presses are not detected.', `${c.bold}${palette.primary}`));
-  console.log(color(`Current octave: ${octave}`, palette.soft));
-
-  readline.emitKeypressEvents(process.stdin);
-  if (!process.stdin.isTTY) {
-    return lineFallbackSeed(octave);
-  }
-
-  process.stdin.setRawMode(true);
-  process.stdin.resume();
-
-  return new Promise<MidiNoteOn>((resolve, reject) => {
-    const cleanup = () => {
-      process.stdin.off('keypress', onKeypress);
-      process.stdin.setRawMode(false);
-      process.stdin.pause();
-    };
-
-    const onKeypress = (str: string, key: { name?: string; shift?: boolean; ctrl?: boolean }) => {
-      if (key.ctrl && key.name === 'c') {
-        cleanup();
-        reject(new Error('Seed note selection cancelled.'));
-        return;
-      }
-
-      if (str === '+' || str === '=') {
-        octave = Math.min(8, octave + 1);
-        console.log(color(`Octave: ${octave}`, palette.soft));
-        return;
-      }
-
-      if (str === '-') {
-        octave = Math.max(0, octave - 1);
-        console.log(color(`Octave: ${octave}`, palette.soft));
-        return;
-      }
-
-      if (key.name === 'q' || key.name === 'escape') {
-        cleanup();
-        reject(new Error('Seed note selection cancelled.'));
-        return;
-      }
-
-      const fromShiftSymbol = SHIFT_MAP[str];
-      const fromKeyName = key.name && /^[1-8]$/.test(key.name) ? Number.parseInt(key.name, 10) : NaN;
-      const degree = Number.isFinite(fromShiftSymbol)
-        ? fromShiftSymbol
-        : Number.isFinite(fromKeyName)
-          ? fromKeyName
-          : NaN;
-
-      if (!Number.isFinite(degree)) return;
-
-      const sharp = Boolean(fromShiftSymbol) || Boolean(key.shift);
-      const pitch = numberToPitch(degree, octave, sharp);
-      const noteName = pitchToName(pitch);
-      console.log(color(`Selected seed: ${noteName} (${pitch})`, palette.primary));
-      cleanup();
-      resolve({ pitch, velocity: 100 });
-    };
-
-    process.stdin.on('keypress', onKeypress);
-  });
-}
-
-// Replace with real MIDI output to your selected synth/device.
-export async function playSequenceToOutput(
-  sequence: GeneratedNote[] | NoteEvent[],
-  options: PlaybackOptions = {},
-): Promise<void> {
-  const events: NoteEvent[] = (sequence as NoteEvent[])[0]?.startMs != null
-    ? (sequence as NoteEvent[])
-    : (() => {
-        const out: NoteEvent[] = [];
-        let t = 0;
-        for (const n of sequence as GeneratedNote[]) {
-          out.push({ pitch: n.pitch, velocity: n.velocity, durationMs: n.durationMs, startMs: t, channel: 0 });
-          t += n.durationMs;
-        }
-        return out;
-      })();
-
-  events.sort((a, b) => a.startMs - b.startMs);
-
-  if (options.instrument) {
-    console.log(
-      color(
-        `MIDI PROGRAM_CHANGE ch=${options.instrument.midiChannel + 1} program=${options.instrument.program} (${options.instrument.label})`,
-        `${c.bold}${palette.primary}`,
-      ),
-    );
-  }
-
-  const beatMs = 60000 / Math.max(1, options.bpm ?? 120);
-  if (options.metronome === 'count-in' || options.metronome === 'always') {
-    for (let i = 0; i < 4; i++) {
-      console.log(color(`METRONOME ${i + 1}`, palette.soft));
-      if (options.beep) process.stdout.write('\x07');
-      // eslint-disable-next-line no-await-in-loop
-      await new Promise((r) => setTimeout(r, beatMs));
-    }
-  }
-
-  let prevStart = 0;
-  for (const note of events) {
-    const wait = Math.max(0, note.startMs - prevStart);
-    if (wait > 0) {
-      // eslint-disable-next-line no-await-in-loop
-      await new Promise((r) => setTimeout(r, wait));
-    }
-    console.log(color(`MIDI OUT NOTE_ON ${note.pitch} ${note.velocity}`, palette.primary));
-    if (options.beep) process.stdout.write('\x07');
-    if (options.metronome === 'always' && note.startMs % Math.max(1, Math.round(beatMs)) < 24) {
-      console.log(color('METRONOME', palette.soft));
-    }
-    // eslint-disable-next-line no-await-in-loop
-    await new Promise((r) => setTimeout(r, note.durationMs));
-    console.log(color(`MIDI OUT NOTE_OFF ${note.pitch}`, palette.primary));
-    prevStart = note.startMs;
-  }
-}

package/src/openExport.ts

@@ -1,24 +0,0 @@
-import { spawn } from 'node:child_process';
-
-export type OpenAfterExport = 'none' | 'finder' | 'garageband';
-
-function runOpen(args: string[]): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn('open', args, { stdio: 'ignore' });
-    child.on('error', reject);
-    child.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`open exited with code ${code ?? -1}`));
-    });
-  });
-}
-
-export async function openExportTarget(path: string, target: OpenAfterExport): Promise<void> {
-  if (target === 'none') return;
-  if (target === 'finder') {
-    await runOpen(['-R', path]);
-    return;
-  }
-  await runOpen(['-a', 'GarageBand', path]);
-}
-

package/src/prompt.ts

@@ -1,25 +0,0 @@
-import type { NextNoteRequest } from './types';
-
-export function systemPrompt(): string {
-  return [
-    'You are a melody continuation engine for MIDI.',
-    'Return JSON only, no markdown, no prose.',
-    'JSON shape: {"pitch":number,"velocity":number,"durationMs":number}.',
-    'pitch must be integer 0..127, velocity integer 1..127, durationMs integer >= 1.',
-  ].join(' ');
-}
-
-export function userPrompt(input: NextNoteRequest): string {
-  return JSON.stringify({
-    instruction: 'Generate exactly one next MIDI note that musically continues the melody.',
-    theme: input.theme,
-    targetLength: input.targetLength,
-    bpm: input.bpm,
-    seedPitch: input.seedPitch,
-    history: input.history,
-    constraints: {
-      maxJumpSemitones: 7,
-      preferredPitchRange: [48, 84],
-    },
-  });
-}

package/src/providers/auth.ts

@@ -1,30 +0,0 @@
-export function normalizeApiKey(raw: string): string {
-  let key = raw.trim();
-  if (key.toLowerCase().startsWith('bearer ')) {
-    key = key.slice(7).trim();
-  }
-  return key;
-}
-
-export function assertHeaderSafeApiKey(provider: string, raw: string): string {
-  const key = normalizeApiKey(raw);
-  if (!key) {
-    throw new Error(`${provider} API key is empty.`);
-  }
-
-  // HTTP header values must be ByteString-safe; reject non-Latin-1 characters.
-  const badIndex = [...key].findIndex((ch) => ch.codePointAt(0)! > 255);
-  if (badIndex >= 0) {
-    const bad = [...key][badIndex];
-    throw new Error(
-      `${provider} API key contains invalid character "${bad}". Re-enter key without extra symbols.`,
-    );
-  }
-
-  if (/\s/.test(key)) {
-    throw new Error(`${provider} API key contains whitespace. Re-enter key.`);
-  }
-
-  return key;
-}
-

package/src/providers/claudeProvider.ts

@@ -1,50 +0,0 @@
-import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
-import { systemPrompt, userPrompt } from '../prompt';
-import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
-
-export class ClaudeProvider implements LLMProvider {
-  constructor(
-    private readonly apiKey: string,
-    private readonly model = 'claude-3-5-sonnet-latest',
-  ) {}
-
-  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
-    const maxRetries = 4;
-    for (let attempt = 0; ; attempt++) {
-      const res = await fetch('https://api.anthropic.com/v1/messages', {
-        method: 'POST',
-        headers: {
-          'x-api-key': this.apiKey,
-          'anthropic-version': '2023-06-01',
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          model: this.model,
-          max_tokens: 120,
-          system: systemPrompt(),
-          messages: [
-            { role: 'user', content: userPrompt(input) },
-          ],
-        }),
-      });
-
-      if (!res.ok) {
-        const text = await res.text();
-        if (attempt < maxRetries && shouldRetryStatus(res.status)) {
-          const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
-          await waitForRetry(delayMs);
-          continue;
-        }
-        throw new Error(`Claude request failed: ${res.status} ${text}`);
-      }
-
-      const json = await res.json() as { content?: Array<{ type?: string; text?: string }> };
-      const text = json.content?.find((item) => item.type === 'text')?.text;
-      if (!text) {
-        throw new Error('Claude response missing text content');
-      }
-
-      return JSON.parse(text) as GeneratedNote;
-    }
-  }
-}

package/src/providers/factory.ts

@@ -1,43 +0,0 @@
-import type { LLMProvider } from '../types';
-import { ClaudeProvider } from './claudeProvider';
-import { GeminiProvider } from './geminiProvider';
-import { GrokProvider } from './grokProvider';
-import { GroqProvider } from './groqProvider';
-import { MockProvider } from './mockProvider';
-import { OpenAIProvider } from './openaiProvider';
-
-export type ProviderName = 'mock' | 'openai' | 'gemini' | 'claude' | 'groq' | 'grok';
-
-export function buildProvider(name: ProviderName): LLMProvider {
-  if (name === 'mock') {
-    return new MockProvider();
-  }
-
-  if (name === 'openai') {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) throw new Error('Missing OPENAI_API_KEY');
-    return new OpenAIProvider(apiKey, process.env.OPENAI_MODEL || 'gpt-4.1-mini');
-  }
-
-  if (name === 'gemini') {
-    const apiKey = process.env.GEMINI_API_KEY;
-    if (!apiKey) throw new Error('Missing GEMINI_API_KEY');
-    return new GeminiProvider(apiKey, process.env.GEMINI_MODEL || 'gemini-2.0-flash');
-  }
-
-  if (name === 'groq') {
-    const apiKey = process.env.GROQ_API_KEY;
-    if (!apiKey) throw new Error('Missing GROQ_API_KEY');
-    return new GroqProvider(apiKey, process.env.GROQ_MODEL || 'llama-3.3-70b-versatile');
-  }
-
-  if (name === 'grok') {
-    const apiKey = process.env.XAI_API_KEY;
-    if (!apiKey) throw new Error('Missing XAI_API_KEY');
-    return new GrokProvider(apiKey, process.env.GROK_MODEL || 'grok-2-latest');
-  }
-
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) throw new Error('Missing ANTHROPIC_API_KEY');
-  return new ClaudeProvider(apiKey, process.env.CLAUDE_MODEL || 'claude-3-5-sonnet-latest');
-}

package/src/providers/geminiProvider.ts

@@ -1,71 +0,0 @@
-import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
-import { assertHeaderSafeApiKey } from './auth';
-import { systemPrompt, userPrompt } from '../prompt';
-import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
-
-type GeminiResponse = {
-  candidates?: Array<{
-    content?: {
-      parts?: Array<{ text?: string }>;
-    };
-  }>;
-};
-
-function extractText(json: GeminiResponse): string {
-  const parts = json.candidates?.[0]?.content?.parts ?? [];
-  return parts
-    .map((p) => (typeof p.text === 'string' ? p.text : ''))
-    .join('')
-    .trim();
-}
-
-export class GeminiProvider implements LLMProvider {
-  constructor(
-    private readonly apiKey: string,
-    private readonly model = 'gemini-2.0-flash',
-  ) {}
-
-  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
-    const apiKey = assertHeaderSafeApiKey('Gemini', this.apiKey);
-    const maxRetries = 4;
-
-    for (let attempt = 0; ; attempt++) {
-      const res = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(this.model)}:generateContent?key=${encodeURIComponent(apiKey)}`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            systemInstruction: {
-              parts: [{ text: systemPrompt() }],
-            },
-            contents: [
-              {
-                role: 'user',
-                parts: [{ text: userPrompt(input) }],
-              },
-            ],
-          }),
-        },
-      );
-
-      if (!res.ok) {
-        const text = await res.text();
-        if (attempt < maxRetries && shouldRetryStatus(res.status)) {
-          const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
-          await waitForRetry(delayMs);
-          continue;
-        }
-        throw new Error(`Gemini request failed: ${res.status} ${text}`);
-      }
-
-      const json = (await res.json()) as GeminiResponse;
-      const text = extractText(json);
-      if (!text) throw new Error('Gemini response missing text content');
-      return JSON.parse(text) as GeneratedNote;
-    }
-  }
-}
-

package/src/providers/grokProvider.ts

@@ -1,69 +0,0 @@
-import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
-import { assertHeaderSafeApiKey } from './auth';
-import { systemPrompt, userPrompt } from '../prompt';
-import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
-
-type ChatCompletionResponse = {
-  choices?: Array<{
-    message?: {
-      content?: string | Array<{ type?: string; text?: string }>;
-    };
-  }>;
-};
-
-type ChatContent = string | Array<{ type?: string; text?: string }> | undefined;
-
-function extractContent(content: ChatContent): string {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((c) => (typeof c?.text === 'string' ? c.text : ''))
-      .join('')
-      .trim();
-  }
-  return '';
-}
-
-export class GrokProvider implements LLMProvider {
-  constructor(
-    private readonly apiKey: string,
-    private readonly model = 'grok-2-latest',
-  ) {}
-
-  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
-    const apiKey = assertHeaderSafeApiKey('Grok', this.apiKey);
-    const maxRetries = 4;
-    for (let attempt = 0; ; attempt++) {
-      const res = await fetch('https://api.x.ai/v1/chat/completions', {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          model: this.model,
-          temperature: 0.7,
-          messages: [
-            { role: 'system', content: systemPrompt() },
-            { role: 'user', content: userPrompt(input) },
-          ],
-        }),
-      });
-
-      if (!res.ok) {
-        const text = await res.text();
-        if (attempt < maxRetries && shouldRetryStatus(res.status)) {
-          const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
-          await waitForRetry(delayMs);
-          continue;
-        }
-        throw new Error(`Grok request failed: ${res.status} ${text}`);
-      }
-
-      const json = (await res.json()) as ChatCompletionResponse;
-      const text = extractContent(json.choices?.[0]?.message?.content);
-      if (!text) throw new Error('Grok response missing content');
-      return JSON.parse(text) as GeneratedNote;
-    }
-  }
-}

package/src/providers/groqProvider.ts

@@ -1,69 +0,0 @@
-import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
-import { assertHeaderSafeApiKey } from './auth';
-import { systemPrompt, userPrompt } from '../prompt';
-import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
-
-type ChatCompletionResponse = {
-  choices?: Array<{
-    message?: {
-      content?: string | Array<{ type?: string; text?: string }>;
-    };
-  }>;
-};
-
-type ChatContent = string | Array<{ type?: string; text?: string }> | undefined;
-
-function extractContent(content: ChatContent): string {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((c) => (typeof c?.text === 'string' ? c.text : ''))
-      .join('')
-      .trim();
-  }
-  return '';
-}
-
-export class GroqProvider implements LLMProvider {
-  constructor(
-    private readonly apiKey: string,
-    private readonly model = 'llama-3.3-70b-versatile',
-  ) {}
-
-  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
-    const apiKey = assertHeaderSafeApiKey('Groq', this.apiKey);
-    const maxRetries = 4;
-    for (let attempt = 0; ; attempt++) {
-      const res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          model: this.model,
-          temperature: 0.7,
-          messages: [
-            { role: 'system', content: systemPrompt() },
-            { role: 'user', content: userPrompt(input) },
-          ],
-        }),
-      });
-
-      if (!res.ok) {
-        const text = await res.text();
-        if (attempt < maxRetries && shouldRetryStatus(res.status)) {
-          const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
-          await waitForRetry(delayMs);
-          continue;
-        }
-        throw new Error(`Groq request failed: ${res.status} ${text}`);
-      }
-
-      const json = (await res.json()) as ChatCompletionResponse;
-      const text = extractContent(json.choices?.[0]?.message?.content);
-      if (!text) throw new Error('Groq response missing content');
-      return JSON.parse(text) as GeneratedNote;
-    }
-  }
-}

package/src/providers/mockProvider.ts

@@ -1,15 +0,0 @@
-import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
-
-// Simple fallback provider for local testing without API keys.
-export class MockProvider implements LLMProvider {
-  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
-    const last = input.history.at(-1)?.pitch ?? input.seedPitch;
-    const stepChoices = [-2, -1, 1, 2, 3];
-    const step = stepChoices[Math.floor(Math.random() * stepChoices.length)];
-    return {
-      pitch: Math.max(48, Math.min(84, last + step)),
-      velocity: 90,
-      durationMs: 300,
-    };
-  }
-}

package/src/providers/openaiProvider.ts

@@ -1,49 +0,0 @@
-import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
-import { assertHeaderSafeApiKey } from './auth';
-import { systemPrompt, userPrompt } from '../prompt';
-import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
-
-export class OpenAIProvider implements LLMProvider {
-  constructor(
-    private readonly apiKey: string,
-    private readonly model = 'gpt-4.1-mini',
-  ) {}
-
-  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
-    const apiKey = assertHeaderSafeApiKey('OpenAI', this.apiKey);
-    const maxRetries = 4;
-    for (let attempt = 0; ; attempt++) {
-      const res = await fetch('https://api.openai.com/v1/responses', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          model: this.model,
-          input: [
-            { role: 'system', content: [{ type: 'input_text', text: systemPrompt() }] },
-            { role: 'user', content: [{ type: 'input_text', text: userPrompt(input) }] },
-          ],
-        }),
-      });
-
-      if (!res.ok) {
-        const text = await res.text();
-        if (attempt < maxRetries && shouldRetryStatus(res.status)) {
-          const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
-          await waitForRetry(delayMs);
-          continue;
-        }
-        throw new Error(`OpenAI request failed: ${res.status} ${text}`);
-      }
-
-      const json = await res.json() as { output_text?: string };
-      if (!json.output_text) {
-        throw new Error('OpenAI response missing output_text');
-      }
-
-      return JSON.parse(json.output_text) as GeneratedNote;
-    }
-  }
-}