@powerfm/libretime-mcp 0.3.0 → 0.5.0

package/README.md

@@ -12,8 +12,11 @@ Tools are organised into subdirectories under `src/tools/` — one file per tool
 
 **Read-only (client & admin)**
 - `get_shows` — list all shows
+- `get_show` — get a single show by ID
+- `get_show_instances` — list scheduled show slots (filterable by show, date range)
 - `get_schedule` — broadcast schedule
 - `get_stream_state` — current on-air state
+- `get_station_info` — station name, timezone, and configuration
 
 **Analytics (admin)**
 - ~~`get_listener_counts`~~ — disabled (API returns full history with no filtering, ~120k records)
@@ -21,13 +24,32 @@ Tools are organised into subdirectories under `src/tools/` — one file per tool
 
 **Media library (admin)**
 - `search_files` — search your media library
-- `upload_file` — upload an audio file _(stdio only — reads from local filesystem)_
+- `upload_file` — upload an audio file via drag-and-drop UI (works in both stdio and HTTP modes — see [File Upload](#file-upload))
 - `update_file_metadata` — edit track metadata
 - `delete_file` — remove a file
 
+**Shows & scheduling (admin)**
+- `create_show` — create a new show
+- `schedule_file` — schedule an uploaded file into a show instance
+
+**Playlists (admin)**
+- `get_playlists` — list all playlists
+- `create_playlist` — create a new playlist
+- `get_playlist_contents` — list items in a playlist
+- `add_to_playlist` — add a file or stream to a playlist
+
 **Users (admin)**
-- `get_users` — list station users
-- `get_hosts` — list show hosts
+- `get_users` — list station users (pass `include_email: true` to include email addresses, omitted by default)
+- `get_hosts` — list show hosts with their show assignments
+
+## File Upload
+
+`upload_file` renders a drag-and-drop UI in the Claude chat window. It works the same way in both transport modes:
+
+- **HTTP mode** — the UI posts directly to the MCP server's `/upload` endpoint
+- **stdio mode** — the admin server spins up a lightweight sidecar HTTP server (default port `4000`) that the UI posts to. The MCP protocol itself continues over stdio; the upload is a side-channel.
+
+Both modes use the same upload token generated at startup, so there's no separate configuration needed. To change the sidecar port in stdio mode set `UPLOAD_PORT` in your environment.
 
 ## Option 1 — Claude Desktop (stdio)
 
@@ -50,13 +72,16 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
       "env": {
         "LIBRETIME_URL": "https://your-instance.example.com",
         "LIBRETIME_USER": "user",
-        "LIBRETIME_PASS": "pass"
+        "LIBRETIME_PASS": "pass",
+        "LIBRETIME_API_KEY": "your_libretime_api_key"
       }
     }
   }
 }
 ```
 
+`LIBRETIME_API_KEY` is the `general.api_key` value from your LibreTime `config.yml`. It is required for file uploads — omit it if you are using the read-only client.
+
 Use `libretime-mcp-client` instead of `libretime-mcp` for read-only access.
 
 ### npx (no install)
@@ -156,8 +181,16 @@ npm run build
 
 # Tests
 npm test
+
+# MCP Inspector — browse and call tools interactively
+npm run inspect:admin           # stdio admin server
+npm run inspect:client          # stdio read-only server
+npm run inspect:admin-http      # HTTP admin (start the server first, then run this)
+npm run inspect:client-http     # HTTP read-only (start the server first, then run this)
 ```
 
+The inspector opens a browser UI at `http://localhost:5173` where you can list tools, see their schemas, and call them with custom inputs.
+
 ## Servers
 
 | Command | Transport | Port | Access |

package/dist/http/admin.js

@@ -9,6 +9,8 @@ import { register as registerShows } from '../tools/shows/index.js';
 import { register as registerAnalytics } from '../tools/analytics/index.js';
 import { register as registerAdmin } from '../tools/admin/index.js';
 import { register as registerFiles } from '../tools/files/index.js';
+import { register as registerPlaylists } from '../tools/playlists/index.js';
+import { register as registerPrompts } from '../prompts/index.js';
 import { registerUploadEndpoint } from './upload.js';
 import { createHttpServer } from './server.js';
 const PORT = parseInt(process.env.MCP_PORT ?? '3000', 10);
@@ -30,5 +32,7 @@ createHttpServer({
         registerAnalytics(server);
         registerAdmin(server);
         registerFiles(server, uploadUrl, UPLOAD_TOKEN);
+        registerPlaylists(server);
+        registerPrompts(server);
     },
 });

package/dist/http/client.js

@@ -5,11 +5,13 @@
 // Intended for network clients. For Claude Desktop use stdio/client.ts.
 import '../env.js';
 import { register as registerShows } from '../tools/shows/index.js';
+import { register as registerPrompts } from '../prompts/index.js';
 import { createHttpServer } from './server.js';
 createHttpServer({
     name: 'libretime-mcp-client',
     defaultPort: 3001,
     register: (server) => {
         registerShows(server);
+        registerPrompts(server);
     },
 });

package/dist/prompts/index.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export function register(server) {
+    server.registerPrompt('on_air_now', {
+        description: 'Check what is currently on air and what is coming up next',
+    }, () => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: 'What is currently on air right now, and what shows are coming up next? Use get_stream_state for the live status and get_schedule to check today\'s schedule.',
+                },
+            }],
+    }));
+    server.registerPrompt('station_status', {
+        description: 'Full station overview — stream state, current schedule, and configuration',
+    }, () => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: 'Give me a full status overview of the station. Check get_stream_state for what is on air, get_schedule for the upcoming schedule, and get_station_info for the station configuration.',
+                },
+            }],
+    }));
+    server.registerPrompt('show_overview', {
+        description: 'Get a full overview of a specific show including upcoming instances',
+        argsSchema: {
+            show_name: z.string().describe('Name of the show'),
+        },
+    }, ({ show_name }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Give me a full overview of the show called "${show_name}". Use get_shows to find it by name, then get_show_instances to list its upcoming scheduled slots.`,
+                },
+            }],
+    }));
+    server.registerPrompt('upload_and_schedule', {
+        description: 'Upload an audio file and schedule it into a show',
+        argsSchema: {
+            show_name: z.string().describe('Name of the show to schedule the file into'),
+        },
+    }, ({ show_name }) => ({
+        messages: [{
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `I want to upload an audio file and schedule it into the show called "${show_name}". Start by using upload_file to get the file from me. Once it is uploaded, use get_shows to find the show, get_show_instances to find the next available instance, then schedule_file to add it to the schedule.`,
+                },
+            }],
+    }));
+    server.registerPrompt('manage_playlist', {
+        description: 'View or manage playlists — list all playlists or inspect a specific one',
+        argsSchema: {
+            playlist_name: z.string().optional().describe('Name of a specific playlist to inspect. Leave blank to list all playlists.'),
+        },
+    }, ({ playlist_name }) => {
+        const text = playlist_name
+            ? `Show me the contents of the playlist called "${playlist_name}". Use get_playlists to find it by name, then get_playlist_contents to list its tracks.`
+            : 'List all playlists in the media library using get_playlists, and show the contents of each one using get_playlist_contents.';
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text } }],
+        };
+    });
+}

package/dist/stdio/admin.js

@@ -8,6 +8,8 @@ import { register as registerShows } from '../tools/shows/index.js';
 import { register as registerAnalytics } from '../tools/analytics/index.js';
 import { register as registerAdmin } from '../tools/admin/index.js';
 import { register as registerFiles } from '../tools/files/index.js';
+import { register as registerPlaylists } from '../tools/playlists/index.js';
+import { register as registerPrompts } from '../prompts/index.js';
 import { registerUploadEndpoint } from '../http/upload.js';
 const { version } = createRequire(import.meta.url)('../../package.json');
 // Spin up a local HTTP server solely for the file upload endpoint.
@@ -29,6 +31,8 @@ registerShows(server);
 registerAnalytics(server);
 registerAdmin(server);
 registerFiles(server, uploadUrl, UPLOAD_TOKEN);
+registerPlaylists(server);
+registerPrompts(server);
 const transport = new StdioServerTransport();
 await server.connect(transport);
 console.error('LibreTime MCP admin server running (shows + analytics + admin)');

package/dist/stdio/client.js

@@ -3,12 +3,14 @@ import { createRequire } from 'module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { register as registerShows } from '../tools/shows/index.js';
+import { register as registerPrompts } from '../prompts/index.js';
 const { version } = createRequire(import.meta.url)('../../package.json');
 const server = new McpServer({
     name: 'libretime-mcp-client',
     version,
 });
 registerShows(server);
+registerPrompts(server);
 const transport = new StdioServerTransport();
 await server.connect(transport);
 console.error('LibreTime MCP client server running (read-only: shows)');

package/dist/tools/admin/get_hosts.js

@@ -3,9 +3,7 @@ import { libreGet } from '../../libretime.js';
 import { toolText } from '../../tool-response.js';
 import { ShowHostSchema, UserSchema } from './types.js';
 export function register(server) {
-    server.registerTool('get_hosts', {
-        description: 'Get all show-to-host assignments. Enriches each entry with user details so you can see which presenter hosts which show by name.',
-    }, async () => {
+    server.tool('get_hosts', 'Get all show-to-host assignments. Enriches each entry with user details so you can see which presenter hosts which show by name.', {}, async () => {
         const [rawHosts, rawUsers] = await Promise.all([
             libreGet('/api/v2/show-hosts'),
             libreGet('/api/v2/users'),

package/dist/tools/admin/get_users.js

@@ -3,13 +3,18 @@ import { libreGet } from '../../libretime.js';
 import { toolText } from '../../tool-response.js';
 import { UserSchema } from './types.js';
 export function register(server) {
-    server.registerTool('get_users', {
-        description: 'List all LibreTime users (presenters and admins). Returns id, username, name, email, and role. Roles: G = Guest, H = Host, P = Manager, A = Admin.',
-    }, async () => {
+    server.tool('get_users', 'List all LibreTime users (presenters and admins). Returns id, username, name, and role. Roles: G = Guest, H = Host, P = Manager, A = Admin.', {
+        include_email: z.boolean().optional().describe('Include email addresses in the response (default: false)'),
+    }, async ({ include_email = false }) => {
         const raw = await libreGet('/api/v2/users');
         const users = z.array(UserSchema).parse(raw);
         const trimmed = users.map(({ id, username, first_name, last_name, email, role }) => ({
-            id, username, first_name, last_name, email, role,
+            id,
+            username,
+            first_name,
+            last_name,
+            ...(include_email ? { email } : {}),
+            role,
         }));
         return toolText(trimmed);
     });

package/dist/tools/admin/index.js

@@ -1,6 +1,10 @@
 import { register as registerGetUsers } from './get_users.js';
 import { register as registerGetHosts } from './get_hosts.js';
+import { register as registerCreateShow } from '../shows/create_show.js';
+import { register as registerScheduleFile } from '../shows/schedule_file.js';
 export function register(server) {
     registerGetUsers(server);
     registerGetHosts(server);
+    registerCreateShow(server);
+    registerScheduleFile(server);
 }

package/dist/tools/admin/types.js

@@ -2,13 +2,13 @@ import { z } from 'zod';
 export const UserSchema = z.object({
     id: z.number(),
     username: z.string(),
-    first_name: z.string(),
-    last_name: z.string(),
-    email: z.string(),
-    role: z.string(),
-});
+    first_name: z.string().nullable(),
+    last_name: z.string().nullable(),
+    email: z.string().nullable(),
+    role: z.string().nullable(),
+}).passthrough();
 export const ShowHostSchema = z.object({
     id: z.number(),
     show: z.number(),
     user: z.number(),
-});
+}).passthrough();

package/dist/tools/playlists/add_to_playlist.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { librePost } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { PlaylistContentSchema } from './types.js';
+export function register(server) {
+    server.tool('add_to_playlist', 'Add a file or stream to a playlist. Use get_playlist_contents to check the current contents and determine the next position.', {
+        playlist_id: z.number().describe('Playlist ID to add to'),
+        file_id: z.number().optional().describe('File ID to add (use for audio files)'),
+        stream_id: z.number().optional().describe('Stream ID to add (use for webstreams)'),
+        position: z.number().optional().describe('Position in the playlist (0-based). Appends to end if omitted.'),
+    }, async ({ playlist_id, file_id, stream_id, position }) => {
+        if (file_id === undefined && stream_id === undefined) {
+            return toolText({ status: 'error', reason: 'Either file_id or stream_id must be provided.' });
+        }
+        const kind = stream_id !== undefined ? 1 : 0;
+        const raw = await librePost('/api/v2/playlist-contents', {
+            playlist: playlist_id,
+            file: file_id ?? null,
+            stream: stream_id ?? null,
+            kind,
+            position: position ?? null,
+            offset: 0,
+            cue_in: '0:00:00.000000',
+            cue_out: null,
+            fade_in: null,
+            fade_out: null,
+        });
+        const content = PlaylistContentSchema.parse(raw);
+        return toolText({ status: 'added', content });
+    });
+}

package/dist/tools/playlists/create_playlist.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { librePost } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { PlaylistSchema } from './types.js';
+export function register(server) {
+    server.tool('create_playlist', 'Create a new playlist in LibreTime. Returns the playlist ID for use with add_to_playlist.', {
+        name: z.string().describe('Playlist name'),
+        description: z.string().optional().describe('Playlist description'),
+    }, async ({ name, description }) => {
+        const raw = await librePost('/api/v2/playlists', {
+            name,
+            description: description ?? null,
+        });
+        const playlist = PlaylistSchema.parse(raw);
+        return toolText(playlist);
+    });
+}

package/dist/tools/playlists/get_playlist_contents.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { PlaylistContentSchema } from './types.js';
+export function register(server) {
+    server.tool('get_playlist_contents', 'List the contents of a playlist.', {
+        playlist_id: z.number().describe('Playlist ID'),
+    }, async ({ playlist_id }) => {
+        const raw = await libreGet('/api/v2/playlist-contents', { playlist: String(playlist_id) });
+        const contents = PlaylistContentSchema.array().parse(raw);
+        return toolText(contents);
+    });
+}

package/dist/tools/playlists/get_playlists.js

@@ -0,0 +1,10 @@
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { PlaylistSchema } from './types.js';
+export function register(server) {
+    server.tool('get_playlists', 'List all playlists in the LibreTime media library.', {}, async () => {
+        const raw = await libreGet('/api/v2/playlists');
+        const playlists = PlaylistSchema.array().parse(raw);
+        return toolText(playlists);
+    });
+}

package/dist/tools/playlists/index.js

@@ -0,0 +1,10 @@
+import { register as registerGetPlaylists } from './get_playlists.js';
+import { register as registerCreatePlaylist } from './create_playlist.js';
+import { register as registerGetPlaylistContents } from './get_playlist_contents.js';
+import { register as registerAddToPlaylist } from './add_to_playlist.js';
+export function register(server) {
+    registerGetPlaylists(server);
+    registerCreatePlaylist(server);
+    registerGetPlaylistContents(server);
+    registerAddToPlaylist(server);
+}

package/dist/tools/playlists/types.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const PlaylistSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    description: z.string().nullable(),
+    length: z.string().nullable(),
+    owner: z.number().nullable(),
+    created_at: z.string().nullable(),
+    updated_at: z.string().nullable(),
+}).passthrough();
+export const PlaylistContentSchema = z.object({
+    id: z.number(),
+    kind: z.number().describe('0=File, 1=Stream, 2=Block'),
+    position: z.number().nullable(),
+    offset: z.number(),
+    length: z.string().nullable(),
+    cue_in: z.string().nullable(),
+    cue_out: z.string().nullable(),
+    fade_in: z.string().nullable(),
+    fade_out: z.string().nullable(),
+    playlist: z.number().nullable(),
+    file: z.number().nullable(),
+    stream: z.number().nullable(),
+}).passthrough();

package/dist/tools/shows/create_show.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { librePost } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ShowSchema } from './types.js';
+export function register(server) {
+    server.tool('create_show', 'Create a new show in LibreTime. Returns the created show with its ID, which can be used to schedule instances.', {
+        name: z.string().describe('Show name'),
+        description: z.string().optional().describe('Show description'),
+        genre: z.string().optional().describe('Genre'),
+        url: z.string().optional().describe('Show website URL'),
+    }, async ({ name, description, genre, url }) => {
+        const raw = await librePost('/api/v2/shows', {
+            name,
+            description: description ?? null,
+            genre: genre ?? null,
+            url: url ?? null,
+            linked: false,
+            linkable: false,
+            auto_playlist_enabled: false,
+            auto_playlist_repeat: false,
+            override_intro_playlist: false,
+            override_outro_playlist: false,
+        });
+        const show = ShowSchema.parse(raw);
+        return toolText(show);
+    });
+}

package/dist/tools/shows/get_show.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ShowSchema } from './types.js';
+export function register(server) {
+    server.tool('get_show', 'Get details of a single LibreTime show by ID.', { id: z.number().describe('Show ID') }, async ({ id }) => {
+        const raw = await libreGet(`/api/v2/shows/${id}`);
+        const show = ShowSchema.parse(raw);
+        return toolText(show);
+    });
+}

package/dist/tools/shows/get_show_instances.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ShowInstanceSchema } from './types.js';
+export function register(server) {
+    server.tool('get_show_instances', 'List scheduled instances of a show. Optionally filter by show ID or date range.', {
+        show_id: z.number().optional().describe('Filter by show ID'),
+        starts_after: z.string().optional().describe('ISO 8601 datetime — only return instances starting after this time'),
+        starts_before: z.string().optional().describe('ISO 8601 datetime — only return instances starting before this time'),
+    }, async ({ show_id, starts_after, starts_before }) => {
+        const params = {};
+        if (show_id !== undefined)
+            params.show = String(show_id);
+        if (starts_after)
+            params.starts_after = starts_after;
+        if (starts_before)
+            params.starts_before = starts_before;
+        const raw = await libreGet('/api/v2/show-instances', params);
+        const instances = ShowInstanceSchema.array().parse(raw);
+        return toolText(instances);
+    });
+}

package/dist/tools/shows/get_station_info.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+const InfoSchema = z.object({
+    station_name: z.string(),
+}).passthrough();
+export function register(server) {
+    server.tool('get_station_info', 'Get basic station information such as the station name.', {}, async () => {
+        const raw = await libreGet('/api/v2/info');
+        const info = InfoSchema.parse(raw);
+        return toolText(info);
+    });
+}

package/dist/tools/shows/index.js

@@ -1,8 +1,14 @@
 import { register as registerGetShows } from './get_shows.js';
+import { register as registerGetShow } from './get_show.js';
+import { register as registerGetShowInstances } from './get_show_instances.js';
 import { register as registerGetSchedule } from './get_schedule.js';
 import { register as registerGetStreamState } from './get_stream_state.js';
+import { register as registerGetStationInfo } from './get_station_info.js';
 export function register(server) {
     registerGetShows(server);
+    registerGetShow(server);
+    registerGetShowInstances(server);
     registerGetSchedule(server);
     registerGetStreamState(server);
+    registerGetStationInfo(server);
 }

package/dist/tools/shows/schedule_file.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { libreGet, librePost } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ScheduleItemSchema } from './types.js';
+import { LibreFileSchema } from '../files/types.js';
+// LibreTime duration format: "H:MM:SS.ffffff" → milliseconds
+function parseDurationMs(length) {
+    if (!length)
+        return null;
+    const match = length.match(/^(\d+):(\d{2}):(\d{2})\.(\d+)$/);
+    if (!match)
+        return null;
+    const [, h, m, s, frac] = match;
+    const ms = Math.round(parseInt(frac.padEnd(3, '0').slice(0, 3)));
+    return (parseInt(h) * 3600 + parseInt(m) * 60 + parseInt(s)) * 1000 + ms;
+}
+export function register(server) {
+    server.tool('schedule_file', 'Schedule an uploaded file into a show instance at a specific time. ' +
+        'Fetches the file duration automatically to calculate the end time. ' +
+        'Use get_show_instances to find the instance ID for the show slot you want to fill.', {
+        instance_id: z.number().describe('Show instance ID to schedule into'),
+        file_id: z.number().describe('ID of the uploaded file to schedule'),
+        starts_at: z.string().describe('ISO 8601 datetime for when the file should start playing'),
+        position: z.number().optional().describe('Position in the show queue (defaults to 0)'),
+    }, async ({ instance_id, file_id, starts_at, position = 0 }) => {
+        // Fetch file to get duration for ends_at / cue_out calculation
+        const fileRaw = await libreGet(`/api/v2/files/${file_id}`);
+        const file = LibreFileSchema.passthrough().parse(fileRaw);
+        const length = file.length;
+        const durationMs = parseDurationMs(length);
+        if (!durationMs) {
+            return toolText({
+                status: 'error',
+                reason: `Could not determine file duration (length: ${length ?? 'null'}). ` +
+                    'The file may still be processing — check import_status and try again.',
+            });
+        }
+        const startsDate = new Date(starts_at);
+        const endsDate = new Date(startsDate.getTime() + durationMs);
+        const ends_at = endsDate.toISOString();
+        const cue_out = length;
+        const raw = await librePost('/api/v2/schedule', {
+            instance: instance_id,
+            file: file_id,
+            starts_at,
+            ends_at,
+            cue_in: '0:00:00.000000',
+            cue_out,
+            position,
+            position_status: 0,
+            broadcasted: 0,
+        });
+        const item = ScheduleItemSchema.parse(raw);
+        return toolText({ status: 'scheduled', item });
+    });
+}

package/dist/tools/shows/types.js

@@ -2,10 +2,27 @@ import { z } from 'zod';
 export const ShowSchema = z.object({
     id: z.number(),
     name: z.string(),
-    description: z.string(),
-    genre: z.string(),
-    url: z.string(),
-});
+    description: z.string().nullable(),
+    genre: z.string().nullable(),
+    url: z.string().nullable(),
+    linked: z.boolean().optional(),
+    linkable: z.boolean().optional(),
+    auto_playlist_enabled: z.boolean().optional(),
+    auto_playlist_repeat: z.boolean().optional(),
+    override_intro_playlist: z.boolean().optional(),
+    override_outro_playlist: z.boolean().optional(),
+}).passthrough();
+export const ShowInstanceSchema = z.object({
+    id: z.number(),
+    starts_at: z.string(),
+    ends_at: z.string(),
+    filled_time: z.string().nullable(),
+    description: z.string().nullable(),
+    modified: z.boolean(),
+    auto_playlist_built: z.boolean(),
+    show: z.number(),
+    instance: z.number().nullable(),
+}).passthrough();
 export const ScheduleItemSchema = z.object({
     id: z.number(),
     starts_at: z.string(),
@@ -13,7 +30,7 @@ export const ScheduleItemSchema = z.object({
     instance: z.number(),
     file: z.number().nullable(),
     broadcasted: z.number(),
-    played: z.boolean(),
+    played: z.boolean().nullable(),
 }).passthrough();
 export const StreamStateSchema = z.object({
     input_main_connected: z.boolean(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerfm/libretime-mcp",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "private": false,
   "type": "module",
   "license": "GPL-3.0",