[Agents Extension] Remove prompt agent handling (#8040)

* Initial changes to remove prompt agents

Signed-off-by: trangevi <trangevi@microsoft.com>

* cleanup

Signed-off-by: trangevi <trangevi@microsoft.com>

* PR comments

Signed-off-by: trangevi <trangevi@microsoft.com>

* PR comments

Signed-off-by: trangevi <trangevi@microsoft.com>

---------

Signed-off-by: trangevi <trangevi@microsoft.com>

Author: trangevi

cli/azd/extensions/azure.ai.agents/internal/cmd/init.go

@@ -23,7 +23,6 @@ import (
 
 	"azureaiagent/internal/exterrors"
 	"azureaiagent/internal/pkg/agents/agent_yaml"
-	"azureaiagent/internal/pkg/agents/registry_api"
 	"azureaiagent/internal/project"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
@@ -594,7 +593,7 @@ func (a *InitAction) Run(ctx context.Context) error {
 		}
 
 		// Prompt for manifest parameters (e.g. tool credentials) after project selection
-		agentManifest, err = registry_api.ProcessManifestParameters(
+		agentManifest, err = agent_yaml.ProcessManifestParameters(
 			ctx, agentManifest, a.azdClient, a.flags.NoPrompt,
 		)
 		if err != nil {
@@ -721,13 +720,8 @@ func getExistingEnvironment(ctx context.Context, envName string, azdClient *azde
 }
 
 // manifestHasModelResources returns true if the manifest contains any model resources
-// that need deployment configuration. Prompt agents always have a model. Hosted agents
-// only need model config if they have resources with kind "model".
+// that need deployment configuration (i.e. resources with kind "model").
 func manifestHasModelResources(manifest *agent_yaml.AgentManifest) bool {
-	if _, ok := manifest.Template.(agent_yaml.PromptAgent); ok {
-		return true
-	}
-
 	if manifest.Resources != nil {
 		for _, resource := range manifest.Resources {
 			if _, ok := resource.(agent_yaml.ModelResource); ok {
@@ -1152,67 +1146,6 @@ func (a *InitAction) isGitHubUrl(manifestPointer string) bool {
 		strings.Contains(hostname, "github")
 }
 
-type RegistryManifest struct {
-	registryName    string
-	manifestName    string
-	manifestVersion string // Defaults to "" if not specified in URL
-}
-
-func (a *InitAction) isRegistryUrl(manifestPointer string) (bool, *RegistryManifest) {
-	// Check if it matches the format "azureml://registries/{registryName}/agentmanifests/{manifestName}[/versions/{manifestVersion}]"
-	if !strings.HasPrefix(manifestPointer, "azureml://") {
-		return false, nil
-	}
-
-	// Remove the "azureml://" prefix
-	path := strings.TrimPrefix(manifestPointer, "azureml://")
-
-	// Split by "/" to get all path components
-	parts := strings.Split(path, "/")
-
-	// Should have either 4 parts (without version) or 6 parts (with version)
-	// Format 1: "registries", registryName, "agentmanifests", manifestName
-	// Format 2: "registries", registryName, "agentmanifests", manifestName, "versions", manifestVersion
-	if len(parts) != 4 && len(parts) != 6 {
-		return false, nil
-	}
-
-	// Validate the expected path structure for the first 4 parts
-	if parts[0] != "registries" || parts[2] != "agentmanifests" {
-		return false, nil
-	}
-
-	// All basic parts should be non-empty
-	registryName := strings.TrimSpace(parts[1])
-	manifestName := strings.TrimSpace(parts[3])
-
-	if registryName == "" || manifestName == "" {
-		return false, nil
-	}
-
-	var manifestVersion string
-
-	// If we have 6 parts, validate the version structure
-	if len(parts) == 6 {
-		if parts[4] != "versions" {
-			return false, nil
-		}
-		manifestVersion = strings.TrimSpace(parts[5])
-		if manifestVersion == "" {
-			return false, nil
-		}
-	} else {
-		// If no version specified, default to ""
-		manifestVersion = ""
-	}
-
-	return true, &RegistryManifest{
-		registryName:    registryName,
-		manifestName:    manifestName,
-		manifestVersion: manifestVersion,
-	}
-}
-
 func (a *InitAction) downloadAgentYaml(
 	ctx context.Context, manifestPointer string, targetDir string) (*agent_yaml.AgentManifest, string, error) {
 	if manifestPointer == "" {
@@ -1394,62 +1327,11 @@ func (a *InitAction) downloadAgentYaml(
 		}
 
 		content = []byte(contentStr)
-	} else if isRegistry, registryManifest := a.isRegistryUrl(manifestPointer); isRegistry {
-		// Handle registry URLs
-		manifestClient := registry_api.NewRegistryAgentManifestClient(registryManifest.registryName, a.credential)
-
-		var versionResult *registry_api.Manifest
-		if registryManifest.manifestVersion == "" {
-			// No version specified, get latest version from GetAllLatest
-			log.Printf("No version provided for manifest '%s', retrieving latest version", registryManifest.manifestName)
-
-			allManifests, err := manifestClient.GetAllLatest(ctx)
-			if err != nil {
-				return nil, "", fmt.Errorf("getting latest manifests: %w", err)
-			}
-
-			// Find the manifest with matching name
-			for _, manifest := range allManifests {
-				if manifest.Name == registryManifest.manifestName {
-					versionResult = &manifest
-					break
-				}
-			}
-
-			if versionResult == nil {
-				return nil, "", fmt.Errorf("manifest '%s' not found in registry '%s'", registryManifest.manifestName, registryManifest.registryName)
-			}
-		} else {
-			// Specific version requested
-			fmt.Println(output.WithGrayFormat("Downloading manifest from registry..."))
-			log.Printf("Downloading manifest from registry: %s", manifestPointer)
-
-			manifest, err := manifestClient.GetManifest(ctx, registryManifest.manifestName, registryManifest.manifestVersion)
-			if err != nil {
-				return nil, "", fmt.Errorf("getting materialized manifest: %w", err)
-			}
-			versionResult = manifest
-		}
-
-		// Process the manifest into a maml format
-		processedManifest, err := registry_api.ProcessRegistryManifest(ctx, versionResult, a.azdClient)
-		if err != nil {
-			return nil, "", fmt.Errorf("processing manifest with parameters: %w", err)
-		}
-
-		log.Print("Retrieved and processed manifest from registry")
-
-		// Convert to YAML bytes for the content variable
-		manifestBytes, err := yaml.Marshal(processedManifest)
-		if err != nil {
-			return nil, "", fmt.Errorf("marshaling agent manifest to YAML: %w", err)
-		}
-		content = manifestBytes
 	} else {
 		// If we reach here, the manifest pointer didn't match any known type
 		return nil, "", exterrors.Validation(
 			exterrors.CodeInvalidManifestPointer,
-			fmt.Sprintf("manifest pointer '%s' is not a valid local file path, GitHub URL, or registry URL", manifestPointer),
+			fmt.Sprintf("manifest pointer '%s' is not a valid local file path or GitHub URL", manifestPointer),
 			"provide a valid URL or an existing local agent.yaml/agent.yml path",
 		)
 	}
@@ -1494,14 +1376,6 @@ func (a *InitAction) downloadAgentYaml(
 		}
 	}
 
-	_, isPromptAgent := agentManifest.Template.(agent_yaml.PromptAgent)
-	if isPromptAgent {
-		agentManifest, err = agent_yaml.ProcessPromptAgentToolsConnections(ctx, agentManifest, a.azdClient)
-		if err != nil {
-			return nil, "", fmt.Errorf("failed to process prompt agent tools connections: %w", err)
-		}
-	}
-
 	// Create target directory if it doesn't exist
 	//nolint:gosec // project scaffold directory should be readable and traversable
 	if err := os.MkdirAll(targetDir, 0755); err != nil {

cli/azd/extensions/azure.ai.agents/internal/cmd/init_models.go

@@ -11,7 +11,6 @@ import (
 
 	"azureaiagent/internal/exterrors"
 	"azureaiagent/internal/pkg/agents/agent_yaml"
-	"azureaiagent/internal/pkg/agents/registry_api"
 	"azureaiagent/internal/project"
 
 	"github.com/azure/azure-dev/cli/azd/pkg/azdext"
@@ -773,17 +772,8 @@ func (a *InitAction) ProcessModels(ctx context.Context, manifest *agent_yaml.Age
 	}
 
 	deploymentDetails := []project.Deployment{}
-	paramValues := registry_api.ParameterValues{}
+	paramValues := agent_yaml.ParameterValues{}
 	switch agentDef.Kind {
-	case agent_yaml.AgentKindPrompt:
-		agentDef := manifest.Template.(agent_yaml.PromptAgent)
-
-		modelDeployment, err := a.getModelDeploymentDetails(ctx, agentDef.Model)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to get model deployment details: %w", err)
-		}
-		deploymentDetails = append(deploymentDetails, *modelDeployment)
-		paramValues["deploymentName"] = modelDeployment.Name
 	case agent_yaml.AgentKindHosted:
 		for _, resource := range manifest.Resources {
 			resourceBytes, err := yaml.Marshal(resource)
@@ -809,7 +799,7 @@ func (a *InitAction) ProcessModels(ctx context.Context, manifest *agent_yaml.Age
 		}
 	}
 
-	updatedManifest, err := registry_api.InjectParameterValuesIntoManifest(manifest, paramValues)
+	updatedManifest, err := agent_yaml.InjectParameterValuesIntoManifest(manifest, paramValues)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to inject deployment names into manifest: %w", err)
 	}

cli/azd/extensions/azure.ai.agents/internal/cmd/init_test.go

@@ -775,34 +775,6 @@ func TestInjectToolboxEnvVarsIntoDefinition_NoopForNilManifest(t *testing.T) {
 	}
 }
 
-func TestInjectToolboxEnvVarsIntoDefinition_NoopForPromptAgent(t *testing.T) {
-	t.Parallel()
-
-	manifest := &agent_yaml.AgentManifest{
-		Template: agent_yaml.PromptAgent{
-			AgentDefinition: agent_yaml.AgentDefinition{
-				Kind: agent_yaml.AgentKindPrompt,
-				Name: "prompt-agent",
-			},
-		},
-		Resources: []any{
-			agent_yaml.ToolboxResource{
-				Resource: agent_yaml.Resource{Name: "tools", Kind: agent_yaml.ResourceKindToolbox},
-				Tools:    []any{map[string]any{"type": "bing_grounding"}},
-			},
-		},
-	}
-
-	if err := injectToolboxEnvVarsIntoDefinition(manifest); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Template should be unchanged (still a PromptAgent, no EnvironmentVariables field)
-	if _, ok := manifest.Template.(agent_yaml.PromptAgent); !ok {
-		t.Error("Expected template to remain a PromptAgent")
-	}
-}
-
 func TestInjectToolboxEnvVarsIntoDefinition_NoopWithoutToolboxes(t *testing.T) {
 	t.Parallel()
 
@@ -1066,14 +1038,6 @@ func TestManifestHasModelResources(t *testing.T) {
 		manifest *agent_yaml.AgentManifest
 		expected bool
 	}{
-		{
-			name: "prompt agent always has model resources",
-			manifest: &agent_yaml.AgentManifest{
-				Name:     "test-prompt",
-				Template: agent_yaml.PromptAgent{},
-			},
-			expected: true,
-		},
 		{
 			name: "hosted agent with model resource",
 			manifest: &agent_yaml.AgentManifest{
@@ -1194,11 +1158,6 @@ func TestResolvePositionalArg(t *testing.T) {
 			arg:        "http://example.com/agent.yaml",
 			isManifest: true,
 		},
-		{
-			name:       "azureml registry URL is manifest",
-			arg:        "azureml://registries/myReg/agentmanifests/myManifest",
-			isManifest: true,
-		},
 		{
 			name:       "custom scheme URL is manifest",
 			arg:        "custom://some/resource",

cli/azd/extensions/azure.ai.agents/internal/pkg/agents/agent_api/models.go

@@ -23,10 +23,8 @@ const (
 type AgentKind string
 
 const (
-	AgentKindPrompt       AgentKind = "prompt"
-	AgentKindHosted       AgentKind = "hosted"
-	AgentKindContainerApp AgentKind = "container_app"
-	AgentKindWorkflow     AgentKind = "workflow"
+	AgentKindHosted   AgentKind = "hosted"
+	AgentKindWorkflow AgentKind = "workflow"
 )
 
 // AgentEventType represents the types of events that can be handled
@@ -81,56 +79,6 @@ type ImageBasedHostedAgentDefinition struct {
 	Image string `json:"image"`
 }
 
-// ContainerAppAgentDefinition represents a container app agent
-type ContainerAppAgentDefinition struct {
-	AgentDefinition
-	ContainerProtocolVersions []ProtocolVersionRecord `json:"container_protocol_versions"`
-	ContainerAppResourceID    string                  `json:"container_app_resource_id"`
-	IngressSubdomainSuffix    string                  `json:"ingress_subdomain_suffix"`
-}
-
-// ResponseTextFormatConfiguration represents text format configuration
-type ResponseTextFormatConfiguration struct {
-	// Implementation depends on OpenAI package structure
-	// This is a placeholder for the actual OpenAI response format configuration
-	Type string `json:"type,omitempty"`
-}
-
-// Reasoning represents OpenAI reasoning configuration
-type Reasoning struct {
-	// Implementation depends on OpenAI package structure
-	// This is a placeholder for the actual OpenAI reasoning structure
-	Effort string `json:"effort,omitempty"`
-}
-
-// ToolArgumentBinding represents binding configuration for tool arguments
-type ToolArgumentBinding struct {
-	ToolName     *string `json:"tool_name,omitempty"`
-	ArgumentName string  `json:"argument_name"`
-}
-
-// StructuredInputDefinition represents a structured input definition
-type StructuredInputDefinition struct {
-	Description          *string               `json:"description,omitempty"`
-	DefaultValue         any                   `json:"default_value,omitempty"`
-	ToolArgumentBindings []ToolArgumentBinding `json:"tool_argument_bindings,omitempty"`
-	Schema               any                   `json:"schema,omitempty"`
-	Required             *bool                 `json:"required,omitempty"`
-}
-
-// PromptAgentDefinition represents a prompt-based agent
-type PromptAgentDefinition struct {
-	AgentDefinition
-	Model            string                               `json:"model"`
-	Instructions     *string                              `json:"instructions,omitempty"`
-	Temperature      *float32                             `json:"temperature,omitempty"`
-	TopP             *float32                             `json:"top_p,omitempty"`
-	Reasoning        *Reasoning                           `json:"reasoning,omitempty"`
-	Tools            []any                                `json:"tools,omitempty"` // Must be a type of Tool
-	Text             *ResponseTextFormatConfiguration     `json:"text,omitempty"`
-	StructuredInputs map[string]StructuredInputDefinition `json:"structured_inputs,omitempty"`
-}
-
 // CreateAgentVersionRequest represents a request to create an agent version
 type CreateAgentVersionRequest struct {
 	Description *string           `json:"description,omitempty"`