busroot-sdk 0.0.7-alpha.6 → 0.0.7-alpha.9

package/build/index.d.ts

@@ -3410,6 +3410,35 @@ declare const ProductionViewModel: z.ZodObject<{
 	skuValue?: number | undefined;
 }>;
 export type ProductionViewModel = z.infer<typeof ProductionViewModel>;
+declare const AgentPostResponse: z.ZodObject<{
+	message: z.ZodString;
+	actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+		name: z.ZodString;
+		params: z.ZodString;
+	}, "strip", z.ZodTypeAny, {
+		params: string;
+		name: string;
+	}, {
+		params: string;
+		name: string;
+	}>, "many">>;
+	debugMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+	message: string;
+	actions?: {
+		params: string;
+		name: string;
+	}[] | undefined;
+	debugMessage?: string | undefined;
+}, {
+	message: string;
+	actions?: {
+		params: string;
+		name: string;
+	}[] | undefined;
+	debugMessage?: string | undefined;
+}>;
+type AgentPostResponse = z.infer<typeof AgentPostResponse>;
 declare const SUPPORTED_DURATION: readonly [
 	"months",
 	"days",
@@ -3740,6 +3769,284 @@ export type ScheduleViewModel = z.infer<typeof ScheduleViewModel>;
 export interface BusrootSignals extends BusrootSignalsPayload {
 	sku_code?: string;
 }
+export interface OverviewProductionAmounts {
+	idealQuantityTotal: number;
+	idealQuantityGood: number;
+	idealQuantityBad: number;
+	actualQuantityTotal: number;
+	actualQuantityGood: number;
+	actualQuantityBad: number;
+	idealValueTotal: number;
+	idealValueGood: number;
+	idealValueBad: number;
+	actualValueTotal: number;
+	actualValueGood: number;
+	actualValueBad: number;
+}
+export interface OverviewMetrics {
+	schedule: {
+		inShiftDurationMs: number;
+		scheduledProductionDurationMs: number;
+		scheduledNonProductionDurationMs: number;
+		unscheduledDurationMs: number;
+		scheduledNonProductionByReason: {
+			reasonCode: string;
+			durationMs: number;
+		}[];
+	};
+	production: {
+		amounts: OverviewProductionAmounts;
+		byHour: {
+			startHour: string;
+			amounts: OverviewProductionAmounts;
+		}[];
+		bySku: {
+			skuCode: string;
+			amounts: OverviewProductionAmounts;
+		}[];
+		byWoRefAndSku: {
+			woRef: string;
+			scheduledDurationMs: number;
+			amounts: OverviewProductionAmounts;
+			skus: {
+				skuCode: string;
+				scheduledDurationMs: number;
+				amounts: OverviewProductionAmounts;
+			}[];
+		}[];
+	};
+	downtime: {
+		totalDurationMs: number;
+		byReason: {
+			reasonCode: string;
+			durationMs: number;
+		}[];
+	};
+	utilisation: {
+		productiveDurationMs: number;
+		inShiftProductiveDurationMs: number;
+		inScheduleProductiveDurationMs: number;
+	};
+}
+export interface OverviewViewModel extends OverviewMetrics {
+	range: {
+		rangeCode: string;
+		duration: number;
+		fromIso: string;
+		toIso: string;
+	};
+	stations: ({
+		code: string;
+		name: string;
+	} & OverviewMetrics)[];
+}
+declare const PlantGetParams: z.ZodObject<{
+	plantCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	plantCode: string;
+}, {
+	plantCode: string;
+}>;
+declare const PlantCreateUpdateParams: z.ZodObject<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	timezone: z.ZodOptional<z.ZodString>;
+	dayStartHour: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	timezone: z.ZodOptional<z.ZodString>;
+	dayStartHour: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	timezone: z.ZodOptional<z.ZodString>;
+	dayStartHour: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const StationGetParams: z.ZodObject<{
+	stationCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	stationCode: string;
+}, {
+	stationCode: string;
+}>;
+declare const StationCreateUpdateParams: z.ZodObject<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	groupCode: z.ZodOptional<z.ZodString>;
+	shiftPatternId: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	groupCode: z.ZodOptional<z.ZodString>;
+	shiftPatternId: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	groupCode: z.ZodOptional<z.ZodString>;
+	shiftPatternId: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const StationSignalParams: z.ZodObject<{
+	stationCode: z.ZodString;
+	payload: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+	stationCode: string;
+	payload: {} & {
+		[k: string]: unknown;
+	};
+}, {
+	stationCode: string;
+	payload: {} & {
+		[k: string]: unknown;
+	};
+}>;
+declare const ProductionGetParams: z.ZodObject<{
+	plantCode: z.ZodString;
+	stationCodes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+	rangeCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	plantCode: string;
+	rangeCode: string;
+	stationCodes?: string[] | undefined;
+}, {
+	plantCode: string;
+	rangeCode: string;
+	stationCodes?: string[] | undefined;
+}>;
+declare const ProductionGetRawParams: z.ZodObject<{
+	plantCode: z.ZodString;
+	stationCodes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+	rangeCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	plantCode: string;
+	rangeCode: string;
+	stationCodes?: string[] | undefined;
+}, {
+	plantCode: string;
+	rangeCode: string;
+	stationCodes?: string[] | undefined;
+}>;
+declare const MetricsGetParams: z.ZodObject<{
+	plantCode: z.ZodString;
+	stationCodes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+	rangeCode: z.ZodString;
+	aggregateWindow: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	plantCode: string;
+	rangeCode: string;
+	aggregateWindow: string;
+	stationCodes?: string[] | undefined;
+}, {
+	plantCode: string;
+	rangeCode: string;
+	aggregateWindow: string;
+	stationCodes?: string[] | undefined;
+}>;
+declare const DowntimeGetParams: z.ZodObject<{
+	plantCode: z.ZodString;
+	stationCodes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+	rangeCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	plantCode: string;
+	rangeCode: string;
+	stationCodes?: string[] | undefined;
+}, {
+	plantCode: string;
+	rangeCode: string;
+	stationCodes?: string[] | undefined;
+}>;
+declare const OverviewGetParams: z.ZodObject<{
+	plantCode: z.ZodString;
+	rangeCode: z.ZodString;
+	rangeFrom: z.ZodOptional<z.ZodString>;
+	rangeTo: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+	plantCode: string;
+	rangeCode: string;
+	rangeFrom?: string | undefined;
+	rangeTo?: string | undefined;
+}, {
+	plantCode: string;
+	rangeCode: string;
+	rangeFrom?: string | undefined;
+	rangeTo?: string | undefined;
+}>;
+declare const SkuGetParams: z.ZodObject<{
+	skuCode: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	skuCode: string;
+}, {
+	skuCode: string;
+}>;
+declare const SkuCreateUpdateParams: z.ZodObject<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	cycleTime: z.ZodOptional<z.ZodNumber>;
+	value: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	cycleTime: z.ZodOptional<z.ZodNumber>;
+	value: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+	code: z.ZodString;
+	name: z.ZodOptional<z.ZodString>;
+	cycleTime: z.ZodOptional<z.ZodNumber>;
+	value: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const ScheduleGetParams: z.ZodObject<{
+	scheduleId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+	scheduleId: number;
+}, {
+	scheduleId: number;
+}>;
+declare const ScheduleCreateUpdateParams: z.ZodObject<{
+	stationCode: z.ZodOptional<z.ZodString>;
+	skuCode: z.ZodOptional<z.ZodString>;
+	plannedStartAt: z.ZodOptional<z.ZodString>;
+	plannedQuantity: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+	stationCode: z.ZodOptional<z.ZodString>;
+	skuCode: z.ZodOptional<z.ZodString>;
+	plannedStartAt: z.ZodOptional<z.ZodString>;
+	plannedQuantity: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+	stationCode: z.ZodOptional<z.ZodString>;
+	skuCode: z.ZodOptional<z.ZodString>;
+	plannedStartAt: z.ZodOptional<z.ZodString>;
+	plannedQuantity: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const AccountCreateParams: z.ZodObject<{
+	domain: z.ZodString;
+	plantName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	domain: string;
+	plantName: string;
+}, {
+	domain: string;
+	plantName: string;
+}>;
+declare const AgentRequestParams: z.ZodObject<{
+	message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	message: string;
+}, {
+	message: string;
+}>;
+export interface ParamDescriptor {
+	name: string;
+	required: boolean;
+	description: string;
+	type: string;
+}
+export interface CapabilityDescriptor {
+	name: string;
+	description: string;
+	method: "GET" | "POST";
+	params: ParamDescriptor[];
+}
+export declare function describeCapabilities(): CapabilityDescriptor[];
 export declare const MqttEventType: {
 	StationMetricNew: string;
 	StationChanged: string;
@@ -3778,65 +4085,55 @@ export declare class BusrootClient {
 	mqttClient: mqtt.MqttClient | undefined;
 	listenersByEventType: Map<"StationMetricNew" | "StationChanged" | "ScheduleChanged" | "ScheduleStarted" | "ScheduleEnded" | "ProductionNew", Set<Listener>>;
 	static version: string;
+	static describe: typeof describeCapabilities;
 	constructor(config: Config);
 	destroy(): void;
 	private get;
 	private post;
-	get profile(): {
+	profile: {
 		get: () => Promise<any>;
 	};
-	get account(): {
-		create: (domain: string, plantName: string) => Promise<{
+	account: {
+		create: ({ domain, plantName }: z.infer<typeof AccountCreateParams>) => Promise<{
 			account: AccountViewModel;
 			apiKey: string;
 		}>;
 	};
-	get apiKey(): {
+	apiKey: {
 		create: () => Promise<ApiKeySchema>;
 	};
-	get plant(): {
-		get: (plantCode: string) => Promise<PlantViewModel>;
-		createUpdate: (plant: Partial<PlantSchema>) => Promise<PlantViewModel>;
+	plant: {
+		get: ({ plantCode }: z.infer<typeof PlantGetParams>) => Promise<PlantViewModel>;
+		createUpdate: (plant: z.infer<typeof PlantCreateUpdateParams>) => Promise<PlantViewModel>;
+	};
+	station: {
+		get: ({ stationCode }: z.infer<typeof StationGetParams>) => Promise<StationViewModel[]>;
+		createUpdate: (station: z.infer<typeof StationCreateUpdateParams>) => Promise<StationViewModel>;
+		signal: (_params: z.infer<typeof StationSignalParams>) => void;
 	};
-	get station(): {
-		get: (stationCode: string) => Promise<StationViewModel[]>;
-		createUpdate: (station: Partial<StationSchema>) => Promise<StationViewModel>;
-		signal: (stationCode: string, payload: BusrootSignals) => void;
+	production: {
+		get: ({ plantCode, stationCodes, rangeCode }: z.infer<typeof ProductionGetParams>) => Promise<ProductionViewModel[]>;
+		getRaw: ({ plantCode, stationCodes, rangeCode }: z.infer<typeof ProductionGetRawParams>) => Promise<ProductionViewModel[]>;
 	};
-	get production(): {
-		get: ({ plantCode, stationCodes, rangeCode, }: {
-			plantCode: string;
-			stationCodes?: string[];
-			rangeCode: string;
-		}) => Promise<ProductionViewModel[]>;
-		getRaw: ({ plantCode, stationCodes, rangeCode, }: {
-			plantCode: string;
-			stationCodes?: string[];
-			rangeCode: string;
-		}) => Promise<ProductionViewModel[]>;
+	metrics: {
+		get: ({ plantCode, stationCodes, rangeCode, aggregateWindow, }: z.infer<typeof MetricsGetParams>) => Promise<AggregatedStationWindowsByStation[]>;
 	};
-	get metrics(): {
-		get: ({ plantCode, stationCodes, rangeCode, aggregateWindow, }: {
-			plantCode: string;
-			stationCodes?: string[];
-			rangeCode: string;
-			aggregateWindow: string;
-		}) => Promise<AggregatedStationWindowsByStation[]>;
+	downtime: {
+		get: ({ plantCode, stationCodes, rangeCode }: z.infer<typeof DowntimeGetParams>) => Promise<AggregatedDowntime[]>;
 	};
-	get downtime(): {
-		get: ({ plantCode, stationCodes, rangeCode, }: {
-			plantCode: string;
-			stationCodes?: string[];
-			rangeCode: string;
-		}) => Promise<AggregatedDowntime[]>;
+	overview: {
+		get: ({ plantCode, rangeCode, rangeFrom, rangeTo }: z.infer<typeof OverviewGetParams>) => Promise<OverviewViewModel>;
 	};
 	sku: {
-		get: (skuCode: string) => Promise<SkuViewModel>;
-		createUpdate: (sku: Partial<SkuViewModel>) => Promise<SkuViewModel>;
+		get: ({ skuCode }: z.infer<typeof SkuGetParams>) => Promise<SkuViewModel>;
+		createUpdate: (sku: z.infer<typeof SkuCreateUpdateParams>) => Promise<SkuViewModel>;
+	};
+	agent: {
+		request: ({ message }: z.infer<typeof AgentRequestParams>) => Promise<AgentPostResponse>;
 	};
 	schedule: {
-		get: (scheduleId: number) => Promise<ScheduleViewModel[]>;
-		createUpdate: (schedule: Partial<ScheduleViewModel>) => Promise<ScheduleViewModel>;
+		get: ({ scheduleId }: z.infer<typeof ScheduleGetParams>) => Promise<ScheduleViewModel[]>;
+		createUpdate: (schedule: z.infer<typeof ScheduleCreateUpdateParams>) => Promise<ScheduleViewModel>;
 	};
 	on(event: MqttEventType, listener: Listener): void;
 	off(event: MqttEventType, listener: Listener): void;
@@ -3849,6 +4146,7 @@ export declare function useBusroot(props?: {
 };
 
 export {
+	AgentPostResponse as AgentResponse,
 	ApiKeySchema as ApiKeyViewModel,
 };
 

package/build/index.js

@@ -1096,6 +1096,7 @@ __export(index_exports, {
   BusrootClient: () => BusrootClient,
   Config: () => Config,
   MqttEventType: () => MqttEventType,
+  describeCapabilities: () => describeCapabilities,
   formattedDateTime: () => import_times.formattedDateTime,
   formattedDuration: () => import_times.formattedDuration,
   useBusroot: () => useBusroot
@@ -1103,7 +1104,236 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
+var import_zod2 = require("zod");
+
+// src/capabilities.ts
 var import_zod = require("zod");
+var PlantGetParams = import_zod.z.object({
+  plantCode: import_zod.z.string().describe("Unique plant identifier code")
+});
+var PlantCreateUpdateParams = import_zod.z.object({
+  code: import_zod.z.string().describe("Unique plant identifier code"),
+  name: import_zod.z.string().optional().describe("Display name for the plant"),
+  timezone: import_zod.z.string().optional().describe("IANA timezone (e.g. Europe/London)"),
+  dayStartHour: import_zod.z.number().optional().describe("Hour the production day starts (0-23)")
+}).passthrough();
+var StationGetParams = import_zod.z.object({
+  stationCode: import_zod.z.string().describe("Unique station identifier code")
+});
+var StationCreateUpdateParams = import_zod.z.object({
+  code: import_zod.z.string().describe("Unique station identifier code"),
+  name: import_zod.z.string().optional().describe("Display name for the station"),
+  groupCode: import_zod.z.string().optional().describe("Group code to assign the station to"),
+  shiftPatternId: import_zod.z.number().optional().describe("Shift pattern ID to assign")
+}).passthrough();
+var StationSignalParams = import_zod.z.object({
+  stationCode: import_zod.z.string().describe("Target station code"),
+  payload: import_zod.z.object({}).passthrough().describe("Signal payload object")
+});
+var ProductionGetParams = import_zod.z.object({
+  plantCode: import_zod.z.string().describe("Plant code to query"),
+  stationCodes: import_zod.z.array(import_zod.z.string()).optional().describe("Filter by station codes"),
+  rangeCode: import_zod.z.string().describe("Time range code (e.g. today, yesterday, last7days)")
+});
+var ProductionGetRawParams = import_zod.z.object({
+  plantCode: import_zod.z.string().describe("Plant code to query"),
+  stationCodes: import_zod.z.array(import_zod.z.string()).optional().describe("Filter by station codes"),
+  rangeCode: import_zod.z.string().describe("Time range code (e.g. today, yesterday, last7days)")
+});
+var MetricsGetParams = import_zod.z.object({
+  plantCode: import_zod.z.string().describe("Plant code to query"),
+  stationCodes: import_zod.z.array(import_zod.z.string()).optional().describe("Filter by station codes"),
+  rangeCode: import_zod.z.string().describe("Time range code (e.g. today, yesterday, last7days)"),
+  aggregateWindow: import_zod.z.string().describe("Aggregation window (e.g. 1h, 1d)")
+});
+var DowntimeGetParams = import_zod.z.object({
+  plantCode: import_zod.z.string().describe("Plant code to query"),
+  stationCodes: import_zod.z.array(import_zod.z.string()).optional().describe("Filter by station codes"),
+  rangeCode: import_zod.z.string().describe("Time range code (e.g. today, yesterday, last7days)")
+});
+var OverviewGetParams = import_zod.z.object({
+  plantCode: import_zod.z.string().describe("Plant code to query"),
+  rangeCode: import_zod.z.string().describe("Time range code (e.g. today, yesterday, last7days)"),
+  rangeFrom: import_zod.z.string().optional().describe("Custom range start (ISO 8601)"),
+  rangeTo: import_zod.z.string().optional().describe("Custom range end (ISO 8601)")
+});
+var SkuGetParams = import_zod.z.object({
+  skuCode: import_zod.z.string().describe("Unique SKU identifier code")
+});
+var SkuCreateUpdateParams = import_zod.z.object({
+  code: import_zod.z.string().describe("Unique SKU identifier code"),
+  name: import_zod.z.string().optional().describe("Display name for the SKU"),
+  cycleTime: import_zod.z.number().optional().describe("Ideal cycle time in seconds"),
+  value: import_zod.z.number().optional().describe("Monetary value per unit")
+}).passthrough();
+var ScheduleGetParams = import_zod.z.object({
+  scheduleId: import_zod.z.number().describe("Numeric schedule ID")
+});
+var ScheduleCreateUpdateParams = import_zod.z.object({
+  stationCode: import_zod.z.string().optional().describe("Station code to assign the schedule to"),
+  skuCode: import_zod.z.string().optional().describe("SKU code for this schedule"),
+  plannedStartAt: import_zod.z.string().optional().describe("Planned start time (ISO 8601)"),
+  plannedQuantity: import_zod.z.number().optional().describe("Planned production quantity")
+}).passthrough();
+var AccountCreateParams = import_zod.z.object({
+  domain: import_zod.z.string().describe("Account domain name"),
+  plantName: import_zod.z.string().describe("Name of the initial plant to create")
+});
+var AgentRequestParams = import_zod.z.object({
+  message: import_zod.z.string().describe("Natural language message to send to the agent")
+});
+var capabilities = [
+  {
+    name: "profile.get",
+    description: "Get the authenticated user's profile",
+    httpMethod: "GET",
+    params: null
+  },
+  {
+    name: "account.create",
+    description: "Create a new account with an initial plant",
+    httpMethod: "POST",
+    params: AccountCreateParams
+  },
+  {
+    name: "apiKey.create",
+    description: "Create a new API key for the current account",
+    httpMethod: "POST",
+    params: null
+  },
+  {
+    name: "plant.get",
+    description: "Get a plant by its code",
+    httpMethod: "GET",
+    params: PlantGetParams
+  },
+  {
+    name: "plant.createUpdate",
+    description: "Create or update a plant",
+    httpMethod: "POST",
+    params: PlantCreateUpdateParams
+  },
+  {
+    name: "station.get",
+    description: "Get stations by station code",
+    httpMethod: "GET",
+    params: StationGetParams
+  },
+  {
+    name: "station.createUpdate",
+    description: "Create or update a station",
+    httpMethod: "POST",
+    params: StationCreateUpdateParams
+  },
+  {
+    name: "station.signal",
+    description: "Send a signal to a station",
+    httpMethod: "POST",
+    params: StationSignalParams
+  },
+  {
+    name: "production.get",
+    description: "Get aggregated production data for a plant and time range",
+    httpMethod: "GET",
+    params: ProductionGetParams
+  },
+  {
+    name: "production.getRaw",
+    description: "Get raw production data for a plant and time range",
+    httpMethod: "GET",
+    params: ProductionGetRawParams
+  },
+  {
+    name: "metrics.get",
+    description: "Get aggregated station metrics (windows) for a plant and time range",
+    httpMethod: "GET",
+    params: MetricsGetParams
+  },
+  {
+    name: "downtime.get",
+    description: "Get aggregated downtime data for a plant and time range",
+    httpMethod: "GET",
+    params: DowntimeGetParams
+  },
+  {
+    name: "overview.get",
+    description: "Get a full overview of plant performance for a time range",
+    httpMethod: "GET",
+    params: OverviewGetParams
+  },
+  {
+    name: "sku.get",
+    description: "Get a SKU by its code",
+    httpMethod: "GET",
+    params: SkuGetParams
+  },
+  {
+    name: "sku.createUpdate",
+    description: "Create or update a SKU",
+    httpMethod: "POST",
+    params: SkuCreateUpdateParams
+  },
+  {
+    name: "schedule.get",
+    description: "Get a schedule by its ID",
+    httpMethod: "GET",
+    params: ScheduleGetParams
+  },
+  {
+    name: "schedule.createUpdate",
+    description: "Create or update a schedule",
+    httpMethod: "POST",
+    params: ScheduleCreateUpdateParams
+  },
+  {
+    name: "agent.request",
+    description: "Send a natural language message to the Busroot AI agent",
+    httpMethod: "POST",
+    params: AgentRequestParams
+  }
+];
+function resolveZodType(schema) {
+  if (schema instanceof import_zod.z.ZodOptional || schema instanceof import_zod.z.ZodNullable) {
+    return resolveZodType(schema.unwrap());
+  }
+  if (schema instanceof import_zod.z.ZodString) {
+    return "string";
+  }
+  if (schema instanceof import_zod.z.ZodNumber) {
+    return "number";
+  }
+  if (schema instanceof import_zod.z.ZodBoolean) {
+    return "boolean";
+  }
+  if (schema instanceof import_zod.z.ZodArray) {
+    return "array";
+  }
+  if (schema instanceof import_zod.z.ZodObject) {
+    return "object";
+  }
+  if (schema instanceof import_zod.z.ZodEnum) {
+    return "string";
+  }
+  return "unknown";
+}
+function describeCapabilities() {
+  return capabilities.map((cap) => ({
+    name: cap.name,
+    description: cap.description,
+    method: cap.httpMethod,
+    params: cap.params ? Object.entries(cap.params.shape).map(([key, value]) => {
+      const zodValue = value;
+      return {
+        name: key,
+        required: !zodValue.isOptional(),
+        description: zodValue.description ?? "",
+        type: resolveZodType(zodValue)
+      };
+    }) : []
+  }));
+}
+
+// src/client.ts
 var import_mqtt = __toESM(require("mqtt"));
 var MqttEventType = {
   StationMetricNew: "STATION_METRIC_NEW",
@@ -1119,13 +1349,13 @@ var MqttEventType = {
   ProductionNew: "PRODUCTION_NEW"
   // When new production is added. NOT IMPLEMENTED FOR MANUAL PRODUCTION YET.
 };
-var Config = import_zod.z.object({
-  accountId: import_zod.z.string().max(255),
-  apiKey: import_zod.z.string().max(255),
-  apiEndpoint: import_zod.z.string().max(255),
-  mqttHost: import_zod.z.string().max(255),
-  enableMqtt: import_zod.z.boolean().optional(),
-  enableDebug: import_zod.z.boolean().optional()
+var Config = import_zod2.z.object({
+  accountId: import_zod2.z.string().max(255),
+  apiKey: import_zod2.z.string().max(255),
+  apiEndpoint: import_zod2.z.string().max(255),
+  mqttHost: import_zod2.z.string().max(255),
+  enableMqtt: import_zod2.z.boolean().optional(),
+  enableDebug: import_zod2.z.boolean().optional()
 });
 var BusrootClient = class {
   constructor(config) {
@@ -1168,6 +1398,7 @@ var BusrootClient = class {
   mqttClient;
   listenersByEventType = /* @__PURE__ */ new Map();
   static version = "v0";
+  static describe = describeCapabilities;
   destroy() {
     if (this.mqttClient != null) {
       this.mqttClient.end();
@@ -1205,121 +1436,104 @@ var BusrootClient = class {
     const resJson = await res.json();
     return resJson;
   }
-  get profile() {
-    return {
-      get: async () => {
-        const res = await this.get("/auth/profile");
-        return res.result;
-      }
-    };
-  }
-  get account() {
-    return {
-      create: async (domain, plantName) => {
-        const res = await this.post("/account/new", { domain, plantName });
-        return res.result;
-      }
-    };
-  }
-  get apiKey() {
-    return {
-      create: async () => {
-        const res = await this.post("/api-key", {});
-        return res.result;
-      }
-    };
-  }
-  get plant() {
-    return {
-      get: async (plantCode) => {
-        const res = await this.get("/plant", { plantCode });
-        return res.result;
-      },
-      createUpdate: async (plant) => {
-        const res = await this.post("/plant", plant);
-        return res.result;
-      }
-    };
-  }
-  get station() {
-    return {
-      get: async (stationCode) => {
-        const res = await this.get("/station", { stationcodes: stationCode });
-        return res.results;
-      },
-      createUpdate: async (station) => {
-        const res = await this.post("/station", station);
-        return res.result;
-      },
-      signal: (stationCode, payload) => {
-        throw new Error("noop");
-      }
-    };
-  }
-  get production() {
-    return {
-      get: async ({
-        plantCode,
-        stationCodes,
-        rangeCode
-      }) => {
-        const res = await this.get("/production", {
-          plantcode: plantCode,
-          stationcodes: stationCodes?.join(","),
-          rangecode: rangeCode
-        });
-        return res.results;
-      },
-      getRaw: async ({
-        plantCode,
-        stationCodes,
-        rangeCode
-      }) => {
-        const res = await this.get("/production/raw", {
-          plantcode: plantCode,
-          stationcodes: stationCodes?.join(","),
-          rangecode: rangeCode
-        });
-        return res.results;
-      }
-    };
-  }
-  get metrics() {
-    return {
-      get: async ({
-        plantCode,
-        stationCodes,
-        rangeCode,
-        aggregateWindow
-      }) => {
-        const res = await this.get("/station-windows", {
-          plantcode: plantCode,
-          stationcodes: stationCodes?.join(","),
-          rangecode: rangeCode,
-          aggregatewindow: aggregateWindow
-        });
-        return res.results;
-      }
-    };
-  }
-  get downtime() {
-    return {
-      get: async ({
-        plantCode,
-        stationCodes,
-        rangeCode
-      }) => {
-        const res = await this.get("/downtime", {
-          plantcode: plantCode,
-          stationcodes: stationCodes?.join(","),
-          rangecode: rangeCode
-        });
-        return res.results;
-      }
-    };
-  }
+  profile = {
+    get: async () => {
+      const res = await this.get("/auth/profile");
+      return res.result;
+    }
+  };
+  account = {
+    create: async ({ domain, plantName }) => {
+      const res = await this.post("/account/new", { domain, plantName });
+      return res.result;
+    }
+  };
+  apiKey = {
+    create: async () => {
+      const res = await this.post("/api-key", {});
+      return res.result;
+    }
+  };
+  plant = {
+    get: async ({ plantCode }) => {
+      const res = await this.get("/plant", { plantCode });
+      return res.result;
+    },
+    createUpdate: async (plant) => {
+      const res = await this.post("/plant", plant);
+      return res.result;
+    }
+  };
+  station = {
+    get: async ({ stationCode }) => {
+      const res = await this.get("/station", { stationcodes: stationCode });
+      return res.results;
+    },
+    createUpdate: async (station) => {
+      const res = await this.post("/station", station);
+      return res.result;
+    },
+    signal: (_params) => {
+      throw new Error("noop");
+    }
+  };
+  production = {
+    get: async ({ plantCode, stationCodes, rangeCode }) => {
+      const res = await this.get("/production", {
+        plantcode: plantCode,
+        stationcodes: stationCodes?.join(","),
+        rangecode: rangeCode
+      });
+      return res.results;
+    },
+    getRaw: async ({ plantCode, stationCodes, rangeCode }) => {
+      const res = await this.get("/production/raw", {
+        plantcode: plantCode,
+        stationcodes: stationCodes?.join(","),
+        rangecode: rangeCode
+      });
+      return res.results;
+    }
+  };
+  metrics = {
+    get: async ({
+      plantCode,
+      stationCodes,
+      rangeCode,
+      aggregateWindow
+    }) => {
+      const res = await this.get("/station-windows", {
+        plantcode: plantCode,
+        stationcodes: stationCodes?.join(","),
+        rangecode: rangeCode,
+        aggregatewindow: aggregateWindow
+      });
+      return res.results;
+    }
+  };
+  downtime = {
+    get: async ({ plantCode, stationCodes, rangeCode }) => {
+      const res = await this.get("/downtime", {
+        plantcode: plantCode,
+        stationcodes: stationCodes?.join(","),
+        rangecode: rangeCode
+      });
+      return res.results;
+    }
+  };
+  overview = {
+    get: async ({ plantCode, rangeCode, rangeFrom, rangeTo }) => {
+      const res = await this.get("/overview", {
+        plantcode: plantCode,
+        rangecode: rangeCode,
+        rangefrom: rangeFrom,
+        rangeto: rangeTo
+      });
+      return res.result;
+    }
+  };
   sku = {
-    get: async (skuCode) => {
+    get: async ({ skuCode }) => {
       const res = await this.get("/sku", { skucodes: skuCode });
       return res.result;
     },
@@ -1328,8 +1542,14 @@ var BusrootClient = class {
       return res.result;
     }
   };
+  agent = {
+    request: async ({ message }) => {
+      const res = await this.post("/agent", { message });
+      return res.result;
+    }
+  };
   schedule = {
-    get: async (scheduleId) => {
+    get: async ({ scheduleId }) => {
       const res = await this.get("/schedule", { ids: String(scheduleId) });
       return res.results;
     },
@@ -1404,6 +1624,7 @@ var import_times = __toESM(require_times());
   BusrootClient,
   Config,
   MqttEventType,
+  describeCapabilities,
   formattedDateTime,
   formattedDuration,
   useBusroot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "busroot-sdk",
-  "version": "0.0.7-alpha.6",
+  "version": "0.0.7-alpha.9",
   "description": "An SDK for accessing Busroot from output.industries",
   "homepage": "https://www.output.industries",
   "main": "./build/index.js",