@ansvar/ch-livestock-mcp 0.1.0

package/src/server.ts

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { createDatabase } from './db.js';
+import { handleAbout } from './tools/about.js';
+import { handleListSources } from './tools/list-sources.js';
+import { handleCheckFreshness } from './tools/check-freshness.js';
+import { handleSearchLivestockGuidance } from './tools/search-livestock-guidance.js';
+import { handleGetWelfareStandards } from './tools/get-welfare-standards.js';
+import { handleGetStockingDensity } from './tools/get-stocking-density.js';
+import { handleGetFeedRequirements } from './tools/get-feed-requirements.js';
+import { handleSearchAnimalHealth } from './tools/search-animal-health.js';
+import { handleGetHousingRequirements } from './tools/get-housing-requirements.js';
+import { handleGetMovementRules } from './tools/get-movement-rules.js';
+import { handleGetBreedingGuidance } from './tools/get-breeding-guidance.js';
+
+const SERVER_NAME = 'ch-livestock-mcp';
+const SERVER_VERSION = '0.1.0';
+
+const TOOLS = [
+  {
+    name: 'about',
+    description: 'Get server metadata: name, version, coverage, data sources, and links.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'list_sources',
+    description: 'List all data sources with authority, URL, license, and freshness info.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'check_data_freshness',
+    description: 'Check when data was last ingested, staleness status, and how to trigger a refresh.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'search_livestock_guidance',
+    description: 'Search across all Swiss livestock topics: welfare, housing, feeding, health, transport, breeds. Use for broad queries about Swiss livestock regulations and guidance.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English)' },
+        species: { type: 'string', description: 'Filter by species (e.g. Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+        limit: { type: 'number', description: 'Max results (default: 20, max: 50)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_welfare_standards',
+    description: 'Get legal minimum welfare requirements and RAUS/BTS programme standards for a species. Based on TSchV and DZV.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        production_system: { type: 'string', description: 'Production system filter (e.g. TSchV-Minimum, RAUS, BTS)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_stocking_density',
+    description: 'Get animals per m2 and space requirements by species, age class, and housing type. Based on TSchV Anhang 1.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        age_class: { type: 'string', description: 'Age/weight class (e.g. Milchkuh, Kalb, Mastschwein >60kg, Legehenne)' },
+        housing_type: { type: 'string', description: 'Housing type (e.g. Laufstall, Anbindestall, Voliere, Freilandhaltung)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_feed_requirements',
+    description: 'Get nutritional requirements per species and production stage. Includes GMF (graslandbasierte Milch- und Fleischproduktion) programme details.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        age_class: { type: 'string', description: 'Age class (e.g. Milchkuh, Aufzuchtrind, Mastschwein, Legehenne)' },
+        production_stage: { type: 'string', description: 'Production stage (e.g. Laktation, Trockenstehend, Mast, Aufzucht)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'search_animal_health',
+    description: 'Search animal health topics: diseases, symptoms, prevention, regulatory reporting requirements.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Search query (e.g. Salmonellen, BVD, Moderhinke, Mastitits)' },
+        species: { type: 'string', description: 'Filter by species' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_housing_requirements',
+    description: 'Get detailed housing specifications: space, ventilation, flooring, temperature. Compares TSchV minimum vs. BTS standard.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        age_class: { type: 'string', description: 'Age class (e.g. Milchkuh, Mastschwein, Legehenne)' },
+        system: { type: 'string', description: 'Housing system (e.g. Laufstall, Anbindestall, Voliere, BTS)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_movement_rules',
+    description: 'Get TVD registration, transport regulations, standstill rules, and Soemmerung/Alpung requirements per species.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde' },
+        rule_type: { type: 'string', description: 'Rule type: TVD, Transport, Soemmerung, Schlachtung' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+  {
+    name: 'get_breeding_guidance',
+    description: 'Get Swiss breed information, breeding calendars, AI (kuenstliche Besamung), genetics, and Soemmerung guidance.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        species: { type: 'string', description: 'Species: Rinder, Schweine, Schafe, Ziegen, Pferde' },
+        topic: { type: 'string', description: 'Topic filter (e.g. Zweinutzung, Milch, Fleisch, Alp)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['species'],
+    },
+  },
+];
+
+const SearchArgsSchema = z.object({
+  query: z.string(),
+  species: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const WelfareArgsSchema = z.object({
+  species: z.string(),
+  production_system: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const StockingArgsSchema = z.object({
+  species: z.string(),
+  age_class: z.string().optional(),
+  housing_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const FeedArgsSchema = z.object({
+  species: z.string(),
+  age_class: z.string().optional(),
+  production_stage: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const HealthSearchArgsSchema = z.object({
+  query: z.string(),
+  species: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const HousingArgsSchema = z.object({
+  species: z.string(),
+  age_class: z.string().optional(),
+  system: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const MovementArgsSchema = z.object({
+  species: z.string(),
+  rule_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const BreedingArgsSchema = z.object({
+  species: z.string(),
+  topic: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+function textResult(data: unknown) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
+}
+
+function errorResult(message: string) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify({ error: message }) }], isError: true };
+}
+
+const db = createDatabase();
+
+const server = new Server(
+  { name: SERVER_NAME, version: SERVER_VERSION },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  try {
+    switch (name) {
+      case 'about':
+        return textResult(handleAbout());
+      case 'list_sources':
+        return textResult(handleListSources(db));
+      case 'check_data_freshness':
+        return textResult(handleCheckFreshness(db));
+      case 'search_livestock_guidance':
+        return textResult(handleSearchLivestockGuidance(db, SearchArgsSchema.parse(args)));
+      case 'get_welfare_standards':
+        return textResult(handleGetWelfareStandards(db, WelfareArgsSchema.parse(args)));
+      case 'get_stocking_density':
+        return textResult(handleGetStockingDensity(db, StockingArgsSchema.parse(args)));
+      case 'get_feed_requirements':
+        return textResult(handleGetFeedRequirements(db, FeedArgsSchema.parse(args)));
+      case 'search_animal_health':
+        return textResult(handleSearchAnimalHealth(db, HealthSearchArgsSchema.parse(args)));
+      case 'get_housing_requirements':
+        return textResult(handleGetHousingRequirements(db, HousingArgsSchema.parse(args)));
+      case 'get_movement_rules':
+        return textResult(handleGetMovementRules(db, MovementArgsSchema.parse(args)));
+      case 'get_breeding_guidance':
+        return textResult(handleGetBreedingGuidance(db, BreedingArgsSchema.parse(args)));
+      default:
+        return errorResult(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return errorResult(err instanceof Error ? err.message : String(err));
+  }
+});
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/tools/about.ts

@@ -0,0 +1,28 @@
+import { buildMeta } from '../metadata.js';
+import { SUPPORTED_JURISDICTIONS } from '../jurisdiction.js';
+
+export function handleAbout() {
+  return {
+    name: 'Switzerland Livestock MCP',
+    description:
+      'Swiss livestock regulations based on the Tierschutzverordnung (TSchV), RAUS/BTS programmes (DZV), ' +
+      'TVD animal movement database, and breed registry data. Covers welfare standards, space requirements, ' +
+      'housing specifications, transport rules, feed requirements, animal health, and breeding guidance ' +
+      'for cattle, pigs, poultry, sheep, goats, and horses in Switzerland.',
+    version: '0.1.0',
+    jurisdiction: [...SUPPORTED_JURISDICTIONS],
+    data_sources: [
+      'Tierschutzverordnung TSchV (BLV)',
+      'Direktzahlungsverordnung DZV — RAUS/BTS (BLW)',
+      'Tierverkehrsdatenbank TVD (Identitas)',
+      'Zuchtorganisationen (Braunvieh Schweiz, swissherdbook, Mutterkuh Schweiz, Suisseporcs)',
+    ],
+    tools_count: 11,
+    links: {
+      homepage: 'https://ansvar.eu/open-agriculture',
+      repository: 'https://github.com/ansvar-systems/ch-livestock-mcp',
+      mcp_network: 'https://ansvar.ai/mcp',
+    },
+    _meta: buildMeta(),
+  };
+}

package/src/tools/check-freshness.ts

@@ -0,0 +1,42 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface FreshnessResult {
+  status: 'fresh' | 'stale' | 'unknown';
+  last_ingest: string | null;
+  build_date: string | null;
+  schema_version: string | null;
+  days_since_ingest: number | null;
+  staleness_threshold_days: number;
+  refresh_command: string;
+  _meta: ReturnType<typeof buildMeta>;
+}
+
+const STALENESS_THRESHOLD_DAYS = 90;
+
+export function handleCheckFreshness(db: Database): FreshnessResult {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+  const buildDate = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['build_date']);
+  const schemaVersion = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['schema_version']);
+
+  let status: 'fresh' | 'stale' | 'unknown' = 'unknown';
+  let daysSinceIngest: number | null = null;
+
+  if (lastIngest?.value) {
+    const ingestDate = new Date(lastIngest.value);
+    const now = new Date();
+    daysSinceIngest = Math.floor((now.getTime() - ingestDate.getTime()) / (1000 * 60 * 60 * 24));
+    status = daysSinceIngest <= STALENESS_THRESHOLD_DAYS ? 'fresh' : 'stale';
+  }
+
+  return {
+    status,
+    last_ingest: lastIngest?.value ?? null,
+    build_date: buildDate?.value ?? null,
+    schema_version: schemaVersion?.value ?? null,
+    days_since_ingest: daysSinceIngest,
+    staleness_threshold_days: STALENESS_THRESHOLD_DAYS,
+    refresh_command: 'gh workflow run ingest.yml -R ansvar-systems/ch-livestock-mcp',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-breeding-guidance.ts

@@ -0,0 +1,53 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface BreedingArgs {
+  species: string;
+  topic?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetBreedingGuidance(db: Database, args: BreedingArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM breeds WHERE LOWER(species) = LOWER(?) AND jurisdiction = ?';
+  const params: unknown[] = [args.species, jv.jurisdiction];
+
+  sql += ' ORDER BY name';
+
+  const breeds = db.all<{
+    id: number; species: string; name: string; purpose: string; notes: string;
+  }>(sql, params);
+
+  if (breeds.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No breed data found for species '${args.species}'. Available species: Rinder, Schweine, Schafe, Ziegen, Pferde.`,
+    };
+  }
+
+  // If topic filter is given, filter breeds/notes by topic keyword
+  let filtered = breeds;
+  if (args.topic) {
+    const topicLower = args.topic.toLowerCase();
+    filtered = breeds.filter(b => {
+      const text = [b.name, b.purpose, b.notes].filter(Boolean).join(' ').toLowerCase();
+      return text.includes(topicLower);
+    });
+    // If topic filter yields nothing, return all breeds with a note
+    if (filtered.length === 0) {
+      filtered = breeds;
+    }
+  }
+
+  return {
+    species: args.species,
+    topic_filter: args.topic ?? null,
+    jurisdiction: jv.jurisdiction,
+    results_count: filtered.length,
+    results: filtered,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-feed-requirements.ts

@@ -0,0 +1,53 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface FeedArgs {
+  species: string;
+  age_class?: string;
+  production_stage?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetFeedRequirements(db: Database, args: FeedArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM feed_requirements WHERE LOWER(species) = LOWER(?) AND jurisdiction = ?';
+  const params: unknown[] = [args.species, jv.jurisdiction];
+
+  if (args.age_class) {
+    sql += ' AND LOWER(age_class) = LOWER(?)';
+    params.push(args.age_class);
+  }
+
+  if (args.production_stage) {
+    sql += ' AND LOWER(production_stage) = LOWER(?)';
+    params.push(args.production_stage);
+  }
+
+  sql += ' ORDER BY age_class, production_stage';
+
+  const results = db.all<{
+    id: number; species: string; age_class: string; production_stage: string;
+    feed_type: string; quantity_kg_day: number | null; energy_mj: number | null;
+    protein_g: number | null; notes: string;
+  }>(sql, params);
+
+  if (results.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No feed requirement data found for species '${args.species}'` +
+        (args.age_class ? ` age class '${args.age_class}'` : '') +
+        (args.production_stage ? ` production stage '${args.production_stage}'` : '') + '.',
+    };
+  }
+
+  return {
+    species: args.species,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-housing-requirements.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface HousingArgs {
+  species: string;
+  age_class?: string;
+  system?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetHousingRequirements(db: Database, args: HousingArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM housing_requirements WHERE LOWER(species) = LOWER(?) AND jurisdiction = ?';
+  const params: unknown[] = [args.species, jv.jurisdiction];
+
+  if (args.age_class) {
+    sql += ' AND LOWER(age_class) = LOWER(?)';
+    params.push(args.age_class);
+  }
+
+  if (args.system) {
+    sql += ' AND LOWER(system) = LOWER(?)';
+    params.push(args.system);
+  }
+
+  sql += ' ORDER BY age_class, system';
+
+  const results = db.all<{
+    id: number; species: string; age_class: string; system: string;
+    space: string; ventilation: string; flooring: string; temperature: string;
+  }>(sql, params);
+
+  if (results.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No housing requirements found for species '${args.species}'` +
+        (args.age_class ? ` age class '${args.age_class}'` : '') +
+        (args.system ? ` system '${args.system}'` : '') + '.',
+    };
+  }
+
+  return {
+    species: args.species,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-movement-rules.ts

@@ -0,0 +1,45 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface MovementArgs {
+  species: string;
+  rule_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetMovementRules(db: Database, args: MovementArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM movement_rules WHERE LOWER(species) = LOWER(?) AND jurisdiction = ?';
+  const params: unknown[] = [args.species, jv.jurisdiction];
+
+  if (args.rule_type) {
+    sql += ' AND LOWER(rule_type) = LOWER(?)';
+    params.push(args.rule_type);
+  }
+
+  sql += ' ORDER BY rule_type';
+
+  const results = db.all<{
+    id: number; species: string; rule_type: string; description: string;
+  }>(sql, params);
+
+  if (results.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No movement rules found for species '${args.species}'` +
+        (args.rule_type ? ` rule type '${args.rule_type}'` : '') + '.',
+    };
+  }
+
+  return {
+    species: args.species,
+    rule_type_filter: args.rule_type ?? null,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-stocking-density.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface StockingArgs {
+  species: string;
+  age_class?: string;
+  housing_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetStockingDensity(db: Database, args: StockingArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM stocking_densities WHERE LOWER(species) = LOWER(?) AND jurisdiction = ?';
+  const params: unknown[] = [args.species, jv.jurisdiction];
+
+  if (args.age_class) {
+    sql += ' AND LOWER(age_class) = LOWER(?)';
+    params.push(args.age_class);
+  }
+
+  if (args.housing_type) {
+    sql += ' AND LOWER(housing_type) = LOWER(?)';
+    params.push(args.housing_type);
+  }
+
+  sql += ' ORDER BY age_class, housing_type';
+
+  const results = db.all<{
+    id: number; species: string; age_class: string; housing_type: string;
+    animals_per_m2: number | null; regulatory_minimum: string;
+  }>(sql, params);
+
+  if (results.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No stocking density data found for species '${args.species}'` +
+        (args.age_class ? ` age class '${args.age_class}'` : '') +
+        (args.housing_type ? ` housing type '${args.housing_type}'` : '') + '.',
+    };
+  }
+
+  return {
+    species: args.species,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-welfare-standards.ts

@@ -0,0 +1,47 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface WelfareArgs {
+  species: string;
+  production_system?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetWelfareStandards(db: Database, args: WelfareArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM welfare_standards WHERE LOWER(species) = LOWER(?) AND jurisdiction = ?';
+  const params: unknown[] = [args.species, jv.jurisdiction];
+
+  if (args.production_system) {
+    sql += ' AND LOWER(production_system) = LOWER(?)';
+    params.push(args.production_system);
+  }
+
+  sql += ' ORDER BY production_system, requirement';
+
+  const results = db.all<{
+    id: number; species: string; production_system: string;
+    requirement: string; min_space_m2: number | null; details: string;
+  }>(sql, params);
+
+  if (results.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No welfare standards found for species '${args.species}'` +
+        (args.production_system ? ` with production system '${args.production_system}'` : '') +
+        '. Available species: Rinder, Schweine, Gefluegel, Schafe, Ziegen, Pferde.',
+    };
+  }
+
+  return {
+    species: args.species,
+    production_system_filter: args.production_system ?? null,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results,
+    _meta: buildMeta(),
+  };
+}