Feature/code deploy zip upload

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

@@ -118,7 +118,8 @@ func (a *InitFromCodeAction) Run(ctx context.Context) error {
 		}
 
 		// Add the agent to the azd project (azure.yaml) services
-		if err := a.addToProject(ctx, srcDir, localDefinition.Name); err != nil {
+		isCodeDeploy := localDefinition.CodeConfiguration != nil
+		if err := a.addToProject(ctx, srcDir, localDefinition.Name, isCodeDeploy); err != nil {
 			return fmt.Errorf("failed to add agent to azure.yaml: %w", err)
 		}
 
@@ -468,6 +469,42 @@ func (a *InitFromCodeAction) createDefinitionFromLocalAgent(ctx context.Context)
 	// TODO: Prompt user for agent kind
 	agentKind := agent_yaml.AgentKindHosted
 
+	// Prompt user for deploy mode (container vs code)
+	deployModeChoices := []*azdext.SelectChoice{
+		{Label: "Code (ZIP upload - no Docker required)", Value: "code"},
+		{Label: "Container (Dockerfile + ACR)", Value: "container"},
+	}
+
+	var deployMode string
+	if a.flags.noPrompt {
+		deployMode = "code" // default to code deploy
+	} else {
+		defaultIdx := int32(0)
+		deployModeResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+			Options: &azdext.SelectOptions{
+				Message:       "How would you like to deploy your agent?",
+				Choices:       deployModeChoices,
+				SelectedIndex: &defaultIdx,
+			},
+		})
+		if err != nil {
+			if exterrors.IsCancellation(err) {
+				return nil, exterrors.Cancelled("deploy mode selection was cancelled")
+			}
+			return nil, fmt.Errorf("failed to prompt for deploy mode: %w", err)
+		}
+		deployMode = deployModeChoices[*deployModeResp.Value].Value
+	}
+
+	// If code deploy, prompt for code configuration details
+	var codeConfig *agent_yaml.CodeConfiguration
+	if deployMode == "code" {
+		codeConfig, err = a.promptCodeConfiguration(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	// Prompt user for supported protocols
 	protocols, err := promptProtocols(ctx, a.azdClient.Prompt(), a.flags.noPrompt, a.flags.protocols)
 	if err != nil {
@@ -587,7 +624,8 @@ func (a *InitFromCodeAction) createDefinitionFromLocalAgent(ctx context.Context)
 			Name: agentName,
 			Kind: agentKind,
 		},
-		Protocols: protocols,
+		Protocols:         protocols,
+		CodeConfiguration: codeConfig,
 	}
 
 	// Add model resource if a model was selected
@@ -793,41 +831,53 @@ func (a *InitFromCodeAction) writeDefinitionToSrcDir(definition *agent_yaml.Cont
 	return definitionPath, nil
 }
 
-func (a *InitFromCodeAction) addToProject(ctx context.Context, targetDir string, agentName string) error {
+func (a *InitFromCodeAction) addToProject(ctx context.Context, targetDir string, agentName string, isCodeDeploy bool) error {
 	var agentConfig = project.ServiceTargetAgentConfig{}
 
-	agentConfig.Container = &project.ContainerSettings{
-		Resources: &project.ResourceSettings{
-			Memory: project.DefaultMemory,
-			Cpu:    project.DefaultCpu,
-		},
+	if !isCodeDeploy {
+		agentConfig.Container = &project.ContainerSettings{
+			Resources: &project.ResourceSettings{
+				Memory: project.DefaultMemory,
+				Cpu:    project.DefaultCpu,
+			},
+		}
 	}
 
 	agentConfig.Deployments = a.deploymentDetails
 
-	// Detect startup command from the project source directory
-	startupCmd, err := resolveStartupCommandForInit(ctx, a.azdClient, a.projectConfig.Path, targetDir, a.flags.noPrompt)
-	if err != nil {
-		return err
+	// Detect startup command from the project source directory (container mode only)
+	if !isCodeDeploy {
+		startupCmd, err := resolveStartupCommandForInit(ctx, a.azdClient, a.projectConfig.Path, targetDir, a.flags.noPrompt)
+		if err != nil {
+			return err
+		}
+		agentConfig.StartupCommand = startupCmd
 	}
-	agentConfig.StartupCommand = startupCmd
 
 	var agentConfigStruct *structpb.Struct
+	var err error
 	if agentConfigStruct, err = project.MarshalStruct(&agentConfig); err != nil {
 		return fmt.Errorf("failed to marshal agent config: %w", err)
 	}
 
+	language := "python"
+	if !isCodeDeploy {
+		language = "docker"
+	}
+
 	serviceConfig := &azdext.ServiceConfig{
 		Name:         strings.ReplaceAll(agentName, " ", ""),
 		RelativePath: targetDir,
 		Host:         AiAgentHost,
-		Language:     "docker",
+		Language:     language,
 		Config:       agentConfigStruct,
 	}
 
-	// For hosted (container-based) agents, set remoteBuild to true by default
-	serviceConfig.Docker = &azdext.DockerProjectOptions{
-		RemoteBuild: true,
+	// For hosted container-based agents, set remoteBuild to true by default
+	if !isCodeDeploy {
+		serviceConfig.Docker = &azdext.DockerProjectOptions{
+			RemoteBuild: true,
+		}
 	}
 
 	req := &azdext.AddServiceRequest{Service: serviceConfig}
@@ -840,6 +890,95 @@ func (a *InitFromCodeAction) addToProject(ctx context.Context, targetDir string,
 	return nil
 }
 
+// promptCodeConfiguration prompts the user for code deploy configuration settings.
+func (a *InitFromCodeAction) promptCodeConfiguration(ctx context.Context) (*agent_yaml.CodeConfiguration, error) {
+	// Prompt for runtime
+	runtimeChoices := []*azdext.SelectChoice{
+		{Label: "Python 3.11", Value: "python_3_11"},
+		{Label: "Python 3.10", Value: "python_3_10"},
+	}
+
+	var runtime string
+	if a.flags.noPrompt {
+		runtime = "python_3_11"
+	} else {
+		defaultIdx := int32(0)
+		runtimeResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+			Options: &azdext.SelectOptions{
+				Message:       "Select the runtime for your agent",
+				Choices:       runtimeChoices,
+				SelectedIndex: &defaultIdx,
+			},
+		})
+		if err != nil {
+			if exterrors.IsCancellation(err) {
+				return nil, exterrors.Cancelled("runtime selection was cancelled")
+			}
+			return nil, fmt.Errorf("failed to prompt for runtime: %w", err)
+		}
+		runtime = runtimeChoices[*runtimeResp.Value].Value
+	}
+
+	// Prompt for entry point
+	defaultEntryPoint := "main.py"
+	// Try to detect entry point from common patterns
+	if _, err := os.Stat("app.py"); err == nil {
+		defaultEntryPoint = "app.py"
+	}
+
+	var entryPoint string
+	if a.flags.noPrompt {
+		entryPoint = defaultEntryPoint
+	} else {
+		entryPointResp, err := a.azdClient.Prompt().Prompt(ctx, &azdext.PromptRequest{
+			Options: &azdext.PromptOptions{
+				Message:      "Enter the entry point file for your agent",
+				DefaultValue: defaultEntryPoint,
+			},
+		})
+		if err != nil {
+			if exterrors.IsCancellation(err) {
+				return nil, exterrors.Cancelled("entry point prompt was cancelled")
+			}
+			return nil, fmt.Errorf("failed to prompt for entry point: %w", err)
+		}
+		entryPoint = entryPointResp.Value
+	}
+
+	// Prompt for dependency resolution
+	depResChoices := []*azdext.SelectChoice{
+		{Label: "Remote build (server installs dependencies)", Value: "remote_build"},
+		{Label: "Bundled (pre-install dependencies locally)", Value: "bundled"},
+	}
+
+	var depResolution string
+	if a.flags.noPrompt {
+		depResolution = "remote_build"
+	} else {
+		defaultIdx := int32(0)
+		depResResp, err := a.azdClient.Prompt().Select(ctx, &azdext.SelectRequest{
+			Options: &azdext.SelectOptions{
+				Message:       "How should dependencies be resolved?",
+				Choices:       depResChoices,
+				SelectedIndex: &defaultIdx,
+			},
+		})
+		if err != nil {
+			if exterrors.IsCancellation(err) {
+				return nil, exterrors.Cancelled("dependency resolution selection was cancelled")
+			}
+			return nil, fmt.Errorf("failed to prompt for dependency resolution: %w", err)
+		}
+		depResolution = depResChoices[*depResResp.Value].Value
+	}
+
+	return &agent_yaml.CodeConfiguration{
+		Runtime:              runtime,
+		EntryPoint:           entryPoint,
+		DependencyResolution: &depResolution,
+	}, nil
+}
+
 // protocolInfo pairs a protocol name with the default version used when generating agent.yaml.
 type protocolInfo struct {
 	Name    string

cli/azd/extensions/azure.ai.agents/internal/exterrors/codes.go

@@ -136,6 +136,7 @@ const (
 	CodeCognitiveServicesClientFailed = "cognitiveservices_client_failed"
 	CodeContainerStartFailed          = "container_start_failed"
 	CodeContainerStartTimeout         = "container_start_timeout"
+	CodeAgentCreateFailed             = "agent_create_failed"
 )
 
 // Operation names for [ServiceFromAzure] errors.

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

@@ -121,6 +121,24 @@ type ImageBasedHostedAgentDefinition struct {
 	Image string `json:"image"`
 }
 
+// CodeConfigurationAPI represents the code_configuration block in the API request
+type CodeConfigurationAPI struct {
+	Runtime              string   `json:"runtime"`
+	EntryPoint           []string `json:"entry_point"`
+	DependencyResolution string   `json:"dependency_resolution,omitempty"`
+}
+
+// CodeBasedHostedAgentDefinition represents a code-deploy hosted agent.
+// Uses protocol_versions (not container_protocol_versions).
+type CodeBasedHostedAgentDefinition struct {
+	AgentDefinition
+	ProtocolVersions     []ProtocolVersionRecord `json:"protocol_versions"`
+	CPU                  string                  `json:"cpu"`
+	Memory               string                  `json:"memory"`
+	EnvironmentVariables map[string]string       `json:"environment_variables,omitempty"`
+	CodeConfiguration    CodeConfigurationAPI    `json:"code_configuration"`
+}
+
 // CreateAgentVersionRequest represents a request to create an agent version
 type CreateAgentVersionRequest struct {
 	Description *string           `json:"description,omitempty"`

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

@@ -356,6 +356,114 @@ func (c *AgentClient) CreateAgentVersion(ctx context.Context, agentName string,
 	return &agentVersion, nil
 }
 
+// CreateAgentFromZip creates a hosted agent via multipart/form-data ZIP code deploy.
+// POST /agents?api-version=...
+func (c *AgentClient) CreateAgentFromZip(
+	ctx context.Context,
+	agentName string,
+	metadata *CreateAgentVersionRequest,
+	zipData []byte,
+	sha256Hex string,
+	apiVersion string,
+) (*AgentObject, error) {
+	reqURL := fmt.Sprintf("%s/agents?api-version=%s", c.endpoint, apiVersion)
+	// For create, include "name" in the metadata JSON (spec requirement)
+	createMeta := &CreateAgentRequest{
+		Name:                      agentName,
+		CreateAgentVersionRequest: *metadata,
+	}
+	return c.zipDeployRequest(ctx, reqURL, agentName, createMeta, zipData, sha256Hex)
+}
+
+// UpdateAgentFromZip updates an existing hosted agent via multipart/form-data ZIP code deploy.
+// POST /agents/{name}?api-version=...
+func (c *AgentClient) UpdateAgentFromZip(
+	ctx context.Context,
+	agentName string,
+	metadata *CreateAgentVersionRequest,
+	zipData []byte,
+	sha256Hex string,
+	apiVersion string,
+) (*AgentObject, error) {
+	reqURL := fmt.Sprintf("%s/agents/%s?api-version=%s", c.endpoint, agentName, apiVersion)
+	return c.zipDeployRequest(ctx, reqURL, "", metadata, zipData, sha256Hex)
+}
+
+// zipDeployRequest performs the multipart ZIP deploy request (shared by create and update).
+func (c *AgentClient) zipDeployRequest(
+	ctx context.Context,
+	reqURL string,
+	agentName string, // if non-empty, sent as x-ms-agent-name header (create only)
+	metadata any,
+	zipData []byte,
+	sha256Hex string,
+) (*AgentObject, error) {
+	// Build multipart body
+	var body bytes.Buffer
+	boundary := "----azd-code-deploy-boundary"
+
+	// Part 1: metadata (JSON)
+	metadataJSON, err := json.Marshal(metadata)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal metadata: %w", err)
+	}
+
+	body.WriteString("--" + boundary + "\r\n")
+	body.WriteString("Content-Disposition: form-data; name=\"metadata\"\r\n")
+	body.WriteString("Content-Type: application/json\r\n\r\n")
+	body.Write(metadataJSON)
+	body.WriteString("\r\n")
+
+	// Part 2: code (ZIP)
+	body.WriteString("--" + boundary + "\r\n")
+	body.WriteString("Content-Disposition: form-data; name=\"code\"; filename=\"agent.zip\"\r\n")
+	body.WriteString("Content-Type: application/zip\r\n\r\n")
+	body.Write(zipData)
+	body.WriteString("\r\n")
+
+	// End boundary
+	body.WriteString("--" + boundary + "--\r\n")
+
+	req, err := runtime.NewRequest(ctx, http.MethodPost, reqURL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	contentType := "multipart/form-data; boundary=" + boundary
+	if err := req.SetBody(streaming.NopCloser(bytes.NewReader(body.Bytes())), contentType); err != nil {
+		return nil, fmt.Errorf("failed to set request body: %w", err)
+	}
+
+	// Required headers
+	req.Raw().Header.Set("Foundry-Features", "CodeAgents=V1Preview,HostedAgents=V1Preview")
+	req.Raw().Header.Set("x-ms-code-zip-sha256", sha256Hex)
+	if agentName != "" {
+		req.Raw().Header.Set("x-ms-agent-name", agentName)
+	}
+
+	resp, err := c.pipeline.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusCreated) {
+		return nil, runtime.NewResponseError(resp)
+	}
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	var agentObj AgentObject
+	if err := json.Unmarshal(respBody, &agentObj); err != nil {
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	return &agentObj, nil
+}
+
 // GetAgentVersion retrieves a specific version of an agent
 func (c *AgentClient) GetAgentVersion(ctx context.Context, agentName, agentVersion, apiVersion string) (*AgentVersionObject, error) {
 	url := fmt.Sprintf("%s/agents/%s/versions/%s?api-version=%s", c.endpoint, agentName, agentVersion, apiVersion)