Use new format in calls to policy API

AGENTS.md

@@ -67,5 +67,5 @@ elastic-package uses the objects-based Fleet API (`PackagePolicy`) — not the d
 - **Input key**: `"{policyTemplate.Name}-{input.Type}"` (e.g. `"apache-logfile"`).
 - **Stream key**: built by `datasetKey(pkgName, ds)` — uses `ds.Dataset` when set, otherwise `"{pkgName}.{ds.Name}"`.
 - **Sibling stream disabling**: Fleet auto-enables all streams for an enabled input unless they are explicitly listed with `enabled: false`. Always send `{enabled: false}` for every sibling data stream sharing the same input type within the same policy template.
-- **Policy template scoping**: When a policy template declares a `data_streams` list, only include data streams from that list as siblings. Use `packages.DataStreamsForInput(packageRoot, policyTemplate, streamInput)` to get the correct set.
-- **Variable format**: the objects-based API expects raw values, not `{"type": ..., "value": ...}` wrappers. `Vars.ToMap()` extracts raw values via `val.Value.Value()`.
+- **Policy template scoping**: When a policy template declares a `data_streams` list, only include data streams from that list as siblings. Use `packages.FilterDatastreamsForPolicyTemplate(datastreams, policyTemplate)` on the result of `packages.ReadAllDataStreamManifests(packageRoot)` to get the correct set.
+- **Variable format**: the objects-based API expects raw values, not `{"type": ..., "value": ...}` wrappers. `Vars.ToMapStr()` extracts raw values via `val.Value.Value()`.

internal/benchrunner/runners/system/runner.go

@@ -487,7 +487,7 @@ func (r *runner) createPackagePolicy(ctx context.Context, pkgManifest *packages.
 	pp.Package.Name = r.scenario.Package
 	pp.Package.Version = r.scenario.Version
 
-	policy, err := r.options.KibanaClient.CreatePackagePolicy(ctx, pp)
+	policy, err := r.options.KibanaClient.CreatePackagePolicy(ctx, pp, kibana.PolicyAPIFormatAuto)
 	if err != nil {
 		return nil, err
 	}

internal/kibana/legacypolicy.go

@@ -0,0 +1,117 @@
+// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+// or more contributor license agreements. Licensed under the Elastic License;
+// you may not use this file except in compliance with the Elastic License.
+
+// Package kibana provides Fleet API client functionality.
+// This file contains the legacy (arrays-based) package policy types and
+// conversion logic used for old Kibana versions.
+
+package kibana
+
+// legacyDataStream identifies a data stream in the legacy package policy format.
+type legacyDataStream struct {
+	Type    string `json:"type"`
+	Dataset string `json:"dataset"`
+}
+
+// legacyStream is one stream entry in the legacy inputs array format.
+type legacyStream struct {
+	ID         string           `json:"id,omitempty"`
+	Enabled    bool             `json:"enabled"`
+	DataStream legacyDataStream `json:"data_stream"`
+	Vars       map[string]Var   `json:"vars,omitempty"`
+}
+
+// legacyInput is one input entry in the legacy inputs array format.
+type legacyInput struct {
+	PolicyTemplate string         `json:"policy_template,omitempty"`
+	Type           string         `json:"type"`
+	Enabled        bool           `json:"enabled"`
+	Vars           map[string]Var `json:"vars,omitempty"`
+	Streams        []legacyStream `json:"streams"`
+}
+
+// legacyPackagePolicy is the legacy (arrays-based) Fleet package policy.
+type legacyPackagePolicy struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Namespace   string `json:"namespace"`
+	PolicyID    string `json:"policy_id"`
+	Enabled     bool   `json:"enabled"`
+	Package     struct {
+		Name    string `json:"name"`
+		Title   string `json:"title"`
+		Version string `json:"version"`
+	} `json:"package"`
+	Inputs   []legacyInput  `json:"inputs"`
+	OutputID string         `json:"output_id"`
+	Vars     map[string]Var `json:"vars,omitempty"`
+	Force    bool           `json:"force"`
+}
+
+// toLegacyMapVar converts Vars to the {value, type} map format expected by the
+// legacy Fleet API.
+func (v Vars) toLegacyMapVar() map[string]Var {
+	if len(v) == 0 {
+		return nil
+	}
+	m := make(map[string]Var, len(v))
+	for k, val := range v {
+		m[k] = val
+	}
+	return m
+}
+
+// toLegacy converts a PackagePolicy (simplified format) to the
+// legacy arrays-based format.
+func (p PackagePolicy) toLegacy() legacyPackagePolicy {
+	legacy := legacyPackagePolicy{
+		Name:        p.Name,
+		Description: p.Description,
+		Namespace:   p.Namespace,
+		PolicyID:    p.PolicyID,
+		Enabled:     true,
+		Force:       p.Force,
+		Vars:        p.legacyVars.toLegacyMapVar(),
+	}
+	legacy.Package.Name = p.Package.Name
+	legacy.Package.Title = p.legacyPackageTitle
+	legacy.Package.Version = p.Package.Version
+	legacy.OutputID = p.OutputID
+
+	// Convert each input from the simplified map to a legacy input entry.
+	// Skip disabled inputs to match the legacy (main-branch) behaviour.
+	for _, i := range p.Inputs {
+		if !i.Enabled {
+			continue
+		}
+		input := legacyInput{
+			PolicyTemplate: i.policyTemplate,
+			Type:           i.inputType,
+			Enabled:        i.Enabled,
+			Vars:           i.legacyVars.toLegacyMapVar(),
+			Streams:        []legacyStream{},
+		}
+
+		// Convert each stream from the simplified map to a legacy stream entry.
+		// Skip disabled streams to match the legacy behaviour.
+		for _, s := range i.Streams {
+			if !s.Enabled {
+				continue
+			}
+			stream := legacyStream{
+				Enabled: s.Enabled,
+				DataStream: legacyDataStream{
+					Type:    s.dataStreamType,
+					Dataset: s.dataStreamDataset,
+				},
+				Vars: s.legacyVars.toLegacyMapVar(),
+			}
+			input.Streams = append(input.Streams, stream)
+		}
+
+		legacy.Inputs = append(legacy.Inputs, input)
+	}
+
+	return legacy
+}